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

Fixed calling of the various insert_ members

This commit is contained in:
Efi Fogel 2012-12-21 00:20:41 +02:00
parent ddcce2767c
commit dda664ecf9
1 changed files with 297 additions and 417 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

446
Arrangement_on_surface_2/include/CGAL/Sweep_line_2/Arr_construction_sl_visitor.h
View File

@ -43,25 +43,18 @@ namespace CGAL {
/*! \struct Integer_hash_function
* An auxiliary hash functor for integers.
*/
struct Integer_hash_function
{
struct Integer_hash_function {
typedef std::size_t result_type;
std::size_t operator() (unsigned int i) const
{
return i;
}
std::size_t operator()(unsigned int i) const { return i; }
};
/*! \class Arr_construction_sl_visitor
* A sweep-line visitor for constructing an arrangement embedded on a surface.
*/
template <class Helper_>
class Arr_construction_sl_visitor :
public Helper_::Base_visitor
{
class Arr_construction_sl_visitor : public Helper_::Base_visitor {
public:
typedef Helper_ Helper;
typedef typename Helper::Traits_2 Traits_2;
@ -74,7 +67,6 @@ public:
typedef typename Traits_2::Point_2 Point_2;
protected:
typedef typename Arrangement_2::Topology_traits Topology_traits;
typedef typename Arrangement_2::Vertex_handle Vertex_handle;
typedef typename Arrangement_2::Halfedge_handle Halfedge_handle;
@ -92,21 +84,18 @@ protected:
Integer_hash_function> Iso_vertices_map;
protected:
Helper m_helper; // The helper class.
Arrangement_2 *m_arr; // The arrangement we construct.
Topology_traits *m_top_traits; // The topology-traits class.
Arr_accessor<Arrangement_2>
m_arr_access; // An arrangement accessor.
Arrangement_2* m_arr; // The arrangement we construct.
Topology_traits* m_top_traits; // The topology-traits class.
Arr_accessor<Arrangement_2> m_arr_access; // An arrangement accessor.
unsigned int m_sc_counter; // Counter for subcurves that may
// represent a hole (the upper
// subcurves that emarge from event
// points with only right curves).
std::vector<Halfedge_handle>
m_sc_he_table; // A table that maps a subcurve
std::vector<Halfedge_handle> m_sc_he_table; // A table that maps a subcurve
// index to its halfedge handle,
// directed from right to left.
@ -120,44 +109,42 @@ protected:
const Vertex_handle m_invalid_vertex; // An invalid vertex handle.
public:
/*! Constructor. */
Arr_construction_sl_visitor (Arrangement_2 *arr) :
m_helper (arr),
m_arr (arr),
m_top_traits (arr->topology_traits()),
m_arr_access (*arr),
m_sc_counter (0),
m_sc_he_table (1),
m_invalid_vertex ()
Arr_construction_sl_visitor(Arrangement_2* arr) :
m_helper(arr),
m_arr(arr),
m_top_traits(arr->topology_traits()),
m_arr_access(*arr),
m_sc_counter(0),
m_sc_he_table(1),
m_invalid_vertex()
{
m_helper.set_halfedge_indices_map (m_he_indices_table);
m_helper.set_halfedge_indices_map(m_he_indices_table);
}
/*! Destructor. */
virtual ~Arr_construction_sl_visitor()
{}
virtual ~Arr_construction_sl_visitor() {}
/// \name Sweep-line notifications.
//@{
/* A notification issued before the sweep process starts. */
inline void before_sweep ();
inline void before_sweep();
/*!
* A notification invoked before the sweep-line starts handling the given
* event.
*/
inline void before_handle_event (Event* event);
inline void before_handle_event(Event* event);
/*!
* A notification invoked after the sweep-line finishes handling the given
* event.
*/
bool after_handle_event (Event* event, Status_line_iterator iter, bool flag);
bool after_handle_event(Event* event, Status_line_iterator iter, bool flag);
/*! A notification invoked when a new subcurve is created. */
void add_subcurve (const X_monotone_curve_2& cv, Subcurve* sc);
void add_subcurve(const X_monotone_curve_2& cv, Subcurve* sc);
//@}
/// \name Insertion functions.
@ -170,7 +157,7 @@ public:
* \return A handle to the inserted halfedge.
*/
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);
/*!
* Insert the given subcurve given its left end-vertex.
@ -180,7 +167,7 @@ public:
* \return A handle to the inserted halfedge.
*/
virtual Halfedge_handle
insert_from_left_vertex (const X_monotone_curve_2& cv, Halfedge_handle he,
insert_from_left_vertex(const X_monotone_curve_2& cv, Halfedge_handle he,
Subcurve* sc);
/*!
@ -191,7 +178,7 @@ public:
* \return A handle to the inserted halfedge.
*/
virtual Halfedge_handle
insert_from_right_vertex (const X_monotone_curve_2& cv,
insert_from_right_vertex(const X_monotone_curve_2& cv,
Halfedge_handle prev,
Subcurve* sc);
@ -204,11 +191,11 @@ public:
* \param new_face_created Output: Whether a new face has been created.
* \return A handle to the inserted halfedge.
*/
virtual Halfedge_handle insert_at_vertices (const X_monotone_curve_2& cv,
virtual Halfedge_handle insert_at_vertices(const X_monotone_curve_2& cv,
Halfedge_handle prev1,
Halfedge_handle prev2,
Subcurve* sc,
bool &new_face_created);
bool& new_face_created);
/*!
* Insert an isolated vertex into the arrangement.
@ -216,7 +203,7 @@ public:
* \param iter The location of the corresponding event in the status line.
* \return A handle to the inserted vertex.
*/
virtual Vertex_handle insert_isolated_vertex (const Point_2& pt,
virtual Vertex_handle insert_isolated_vertex(const Point_2& pt,
Status_line_iterator iter);
/*!
@ -229,13 +216,12 @@ public:
//@}
/*! Get the last event associated with the given subcurve. */
Event* last_event_on_subcurve (Subcurve* sc)
Event* last_event_on_subcurve(Subcurve* sc)
{
return (reinterpret_cast<Event*>((sc)->last_event()));
}
private:
/// \name Auxiliary functions.
//@{
@ -244,9 +230,9 @@ private:
* These two types may not be the same when the addition visitor inherits
* from this base class.
*/
inline const typename Arrangement_2::Point_2& _point (const Point_2& p) const
inline const typename Arrangement_2::Point_2& _point(const Point_2& p) const
{
return (static_cast<const typename Arrangement_2::Point_2&> (p));
return (static_cast<const typename Arrangement_2::Point_2&>(p));
}
/*!
@ -256,13 +242,13 @@ private:
* from this base class.
*/
inline const typename Arrangement_2::X_monotone_curve_2&
_curve (const X_monotone_curve_2& cv) const
_curve(const X_monotone_curve_2& cv) const
{
return (static_cast<const typename Arrangement_2::X_monotone_curve_2&>(cv));
}
/*! Map the given subcurve index to the given halfedge handle. */
void _map_new_halfedge (unsigned int i, Halfedge_handle he);
void _map_new_halfedge(unsigned int i, Halfedge_handle he);
//@}
};
@ -274,12 +260,10 @@ private:
// A notification issued before the sweep process starts.
//
template <class Hlpr>
void Arr_construction_sl_visitor<Hlpr>::before_sweep ()
void Arr_construction_sl_visitor<Hlpr>::before_sweep()
{
// We just have to notify the helper that the sweep process now starts.
m_helper.before_sweep();
return;
}
//-----------------------------------------------------------------------------
@ -287,14 +271,13 @@ void Arr_construction_sl_visitor<Hlpr>::before_sweep ()
// event.
//
template <class Hlpr>
void Arr_construction_sl_visitor<Hlpr>::before_handle_event (Event* event)
void Arr_construction_sl_visitor<Hlpr>::before_handle_event(Event* event)
{
// We just have to notify the helper class on the event.
m_helper.before_handle_event (event);
#if 0
m_helper.before_handle_event(event);
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV before_handle_event" << std::endl;
#endif
return;
}
//-----------------------------------------------------------------------------
@ -302,16 +285,16 @@ void Arr_construction_sl_visitor<Hlpr>::before_handle_event (Event* event)
// event.
//
template <class Hlpr>
bool Arr_construction_sl_visitor<Hlpr>::after_handle_event
(Event* event, Status_line_iterator iter, bool /* flag */)
bool Arr_construction_sl_visitor<Hlpr>::
after_handle_event(Event* event, Status_line_iterator iter, bool /* flag */)
{
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << std::endl << "CGAL_CSLV after_handle_event: " << event << std::endl;
std::cout << std::endl << "CGAL_CSLV after_handle_event: " << event
<< std::endl;
#endif
// Check if the event represents an isolated vertex.
if (!event->has_left_curves() && !event->has_right_curves())
{
if (!event->has_left_curves() && !event->has_right_curves()) {
// There are no incident subcurves, so this event is an isolated vertex.
// We map the current index to this vertex, and add this index to the
// indices list of the curve the vertex "sees" from below.
@ -321,21 +304,19 @@ bool Arr_construction_sl_visitor<Hlpr>::after_handle_event
m_iso_verts_map[m_sc_counter] = v;
_map_new_halfedge(m_sc_counter, Halfedge_handle());
if (iter != this->status_line_end())
{
if (iter != this->status_line_end()) {
// The isolated vertex "sees" the subcurve of the given position from
// below.
Subcurve *sc_above = *iter;
Subcurve* sc_above = *iter;
sc_above->add_halfedge_index(m_sc_counter);
}
else
{
else {
// The vertex is not located below any valid curve, so we use the helper
// class to mark that this index should belong to the current top face.
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV adding a " << m_sc_counter << std::endl;
#endif
m_helper.add_subcurve_in_top_face (m_sc_counter);
m_helper.add_subcurve_in_top_face(m_sc_counter);
}
// The event can now be deallocated.
@ -364,8 +345,7 @@ bool Arr_construction_sl_visitor<Hlpr>::after_handle_event
}
// Check if the event has only incident subcurves from its right.
if (!event->has_left_curves())
{
if (!event->has_left_curves()) {
CGAL_assertion(event->has_right_curves());
// In case of a finite event that has no incident left curves, it is
@ -373,29 +353,27 @@ bool Arr_construction_sl_visitor<Hlpr>::after_handle_event
// We give index to the topmost subcurve from the right, and add this
// vertex indices list of the curve the event "sees" from below.
m_sc_counter++;
(*(event->right_curves_rbegin()))->set_index (m_sc_counter);
(*(event->right_curves_rbegin()))->set_index(m_sc_counter);
if (iter != this->status_line_end())
{
if (iter != this->status_line_end()) {
// The vertex "sees" the subcurve of the given position from below.
Subcurve *sc_above = *iter;
sc_above->add_halfedge_index(m_sc_counter);
}
else
{
else {
// The vertex is not located below any valid curve, so we use the helper
// class to mark that this index should belong to the current top face.
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV adding b " << m_sc_counter << std::endl;
#endif
m_helper.add_subcurve_in_top_face (m_sc_counter);
m_helper.add_subcurve_in_top_face(m_sc_counter);
}
}
// Set the last event of all left subcurve (thus, this event corresponds
// to their right endpoint).
Event_subcurve_iterator left_it;
for(left_it = event->left_curves_begin();
for (left_it = event->left_curves_begin();
left_it != event->left_curves_end();
++left_it)
{
@ -403,21 +381,20 @@ bool Arr_construction_sl_visitor<Hlpr>::after_handle_event
}
// In case there are no right subcurves, the event can be deallocated.
if(event->number_of_right_curves() == 0)
{
if (event->number_of_right_curves() == 0) {
// Inform the helper class that the event will soon be deallocated.
m_helper.before_deallocate_event (event);
m_helper.before_deallocate_event(event);
return (true);
}
// Mark that all right subcurves incident to the current event are not
// in the arrangement yet.
event->init_subcurve_in_arrangement_flags (event->number_of_right_curves());
event->init_subcurve_in_arrangement_flags(event->number_of_right_curves());
// Set the last event of all right subcurve (thus, this event corresponds
// to their left endpoint).
Event_subcurve_iterator right_it;
for(right_it = event->right_curves_begin();
for (right_it = event->right_curves_begin();
right_it != event->right_curves_end();
++right_it)
{
@ -433,7 +410,7 @@ bool Arr_construction_sl_visitor<Hlpr>::after_handle_event
//
template <class Hlpr>
void Arr_construction_sl_visitor<Hlpr>::
add_subcurve (const X_monotone_curve_2& cv, Subcurve* sc)
add_subcurve(const X_monotone_curve_2& cv, Subcurve* sc)
{
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << std::endl << "CGAL_CSLV add_subcurve: " << cv << std::endl;
@ -441,7 +418,7 @@ add_subcurve (const X_monotone_curve_2& cv, Subcurve* sc)
// Obtain all information to perform the insertion of the subcurve into
// the arrangement.
Event *last_event = last_event_on_subcurve(sc);
Event* last_event = last_event_on_subcurve(sc);
Halfedge_handle res;
Halfedge_handle he_right = this->current_event()->halfedge_handle();
Halfedge_handle he_left = last_event->halfedge_handle();
@ -479,68 +456,31 @@ add_subcurve (const X_monotone_curve_2& cv, Subcurve* sc)
}
#endif
// Check if the previous event on the curve is not in the arrangement yet.
if (he_left == invalid_he)
{
// We do not have a handle from the previous insert.
if (he_right != invalid_he)
{
// We have a handle from the current event, representing the right end
// of the subcurve - use it to insert the subcurve.
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV call insert_from_right_vertex" << std::endl;
#endif
res = this->insert_from_right_vertex(cv, he_right, sc);
}
else
{
// We do not have handles for any of the curve end, so we insert it in
// the interior of a face.
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV call insert_in_face_interior" << std::endl;
#endif
// Check whether the previous event on the curve is not in the arrangement yet.
if (he_left == invalid_he) {
Vertex_handle v_left = last_event->vertex_handle();
// Check whether the vertex to be associated with the left end of
// the curve has already been created.
if ((v_left != m_invalid_vertex) && (v_left->degree() > 0)) {
// The left vertex, v_left, is a boundary vertex, which already has
// some incident halfedges. We look for the predecessor halfedge and
// insert the curve from this left vertex.
// The left vertex v is a boundary vertex which already has some
// incident halfedges. We look for the predecessor halfedge and
// insert the curve between two existing vertices.
Arr_parameter_space bx = last_event->parameter_space_in_x();
Arr_parameter_space by = last_event->parameter_space_in_y();
CGAL_assertion((bx != ARR_INTERIOR) || (by != ARR_INTERIOR));
Halfedge_handle l_prev = Halfedge_handle
he_left = Halfedge_handle
(m_top_traits->locate_around_boundary_vertex(&(*v_left), _curve(cv),
ARR_MIN_END, bx, by));
res = this->insert_from_left_vertex(cv, l_prev, sc);
}
}
else {
Event* curr_event = this->current_event();
Vertex_handle v_right = curr_event->vertex_handle();
if ((v_right != m_invalid_vertex) && (v_right->degree() > 0)) {
// The right vertex v_right is a boundary vertex which already has
// some incident halfedges. We look for the predecessor halfedge and
// insert the curve from this right vertex.
Arr_parameter_space bx = curr_event->parameter_space_in_x();
Arr_parameter_space by = curr_event->parameter_space_in_y();
CGAL_assertion((bx != ARR_INTERIOR) || (by != ARR_INTERIOR));
Halfedge_handle r_prev = Halfedge_handle
(m_top_traits->locate_around_boundary_vertex(&(*v_right), _curve(cv),
ARR_MAX_END, bx, by));
res = this->insert_from_right_vertex (cv, r_prev, sc);
}
else
res = this->insert_in_face_interior(cv, sc);
}
}
}
else
{
// The previous event on the curve is already in the arrangement,
// therefore we use it to insert the subcurve.
// The previous event on the curve is already in the arrangement.
// Therefore, we use it to insert the subcurve.
// First, we skip some halfedges around the left vertex to get the true
// predecessor halfedge for the insertion.
for (int i = 0; i < jump; i++) {
for (int i = 0; i < jump; i++)
he_left = (he_left->next())->twin();
}
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
if (jump != 0) {
std::cout << "CGAL_CSLV JUMP: " << jump << std::endl;
@ -553,35 +493,44 @@ add_subcurve (const X_monotone_curve_2& cv, Subcurve* sc)
std::cout << "he_leftfac : " << &(*he_left->face()) << std::endl;
}
#endif
}
if (he_right != invalid_he)
{
CGAL_assertion (he_left->face() == he_right->face());
// Check whether the current event is already in the arrangement
if (he_right == invalid_he) {
// We do not have handles for any of the curve end, so we insert it in
// the interior of a face.
Event* curr_event = this->current_event();
Vertex_handle v_right = curr_event->vertex_handle();
if ((v_right != m_invalid_vertex) && (v_right->degree() > 0)) {
// The left vertex v is a boundary vertex which already has some
// incident halfedges. We look for the predecessor halfedge and
// insert the curve from this right vertex.
Arr_parameter_space bx = curr_event->parameter_space_in_x();
Arr_parameter_space by = curr_event->parameter_space_in_y();
CGAL_assertion((bx != ARR_INTERIOR) || (by != ARR_INTERIOR));
he_right = Halfedge_handle
(m_top_traits->locate_around_boundary_vertex(&(*v_right), _curve(cv),
ARR_MAX_END, bx, by));
}
}
// We also have a handle for the current event, representing the right
// vertex of the subcurve. We insert the subcurve using the two
// predecessor halfedges.
// Check whether the verteices to be associated with the left end and
// the right end of the curve have already been created.
bool dummy;
res = (he_left != invalid_he) ?
((he_right != invalid_he) ?
this->insert_at_vertices(cv, he_right, he_left, sc, dummy) :
this->insert_from_left_vertex(cv, he_left, sc)) :
((he_right != invalid_he) ?
this->insert_from_right_vertex(cv, he_right, sc) :
this->insert_in_face_interior(cv, sc));
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV call insert_at_vertices" << std::endl;
#endif
res = this->insert_at_vertices (cv, he_right, he_left, sc, dummy);
}
else
{
// We only have a handle for the predecessor halfedge of the left end
// of the subcurve - use it to insert the subcurve.
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV call insert_from_left_vertex" << std::endl;
#endif
res = this->insert_from_left_vertex (cv, he_left, sc);
}
}
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV res: " << &(*res) << " with face " << &(*res->face()) << " is " << res->direction() << std::endl;
std::cout << "CGAL_CSLV twi: " << &(*res->twin()) << " with face " << &(*res->twin()->face()) << " is " << res->twin()->direction() << std::endl;
std::cout << "CGAL_CSLV res: " << &(*res) << " with face " << &(*res->face())
<< " is " << res->direction() << std::endl;
std::cout << "CGAL_CSLV twi: " << &(*res->twin()) << " with face "
<< &(*res->twin()->face()) << " is " << res->twin()->direction()
<< std::endl;
#endif
// Make sure that res is a halfedge that is always directed from left to
@ -605,10 +554,9 @@ add_subcurve (const X_monotone_curve_2& cv, Subcurve* sc)
}
// If sc has valid index, insert its index to m_sc_he_table.
if(sc->has_valid_index())
{
if (sc->has_valid_index()) {
CGAL_assertion(res->twin()->direction() == ARR_RIGHT_TO_LEFT);
_map_new_halfedge (sc->index(), res->twin());
_map_new_halfedge(sc->index(), res->twin());
}
}
@ -620,16 +568,13 @@ add_subcurve (const X_monotone_curve_2& cv, Subcurve* sc)
// In case the event has no more right subcurves associated with it, we can
// deallocate it. Note that we inform the helper class before deallocating
// the event.
if (last_event->dec_right_curves_counter() == 0)
{
m_helper.before_deallocate_event (last_event);
this->deallocate_event (last_event);
if (last_event->dec_right_curves_counter() == 0) {
m_helper.before_deallocate_event(last_event);
this->deallocate_event(last_event);
}
// Clear the list of indices of the subcurve.
sc->clear_halfedge_indices();
return;
}
//-----------------------------------------------------------------------------
@ -638,42 +583,37 @@ add_subcurve (const X_monotone_curve_2& cv, Subcurve* sc)
template <class Hlpr>
typename Arr_construction_sl_visitor<Hlpr>::Halfedge_handle
Arr_construction_sl_visitor<Hlpr>::
insert_in_face_interior (const X_monotone_curve_2& cv, Subcurve* sc)
insert_in_face_interior(const X_monotone_curve_2& cv, Subcurve* sc)
{
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV insert_in_face_interior\ncurve: " << cv << std::endl;
#endif
// Check if the vertex to be associated with the left end of the curve has
// already been created.
Event* last_event = last_event_on_subcurve(sc);
Vertex_handle v1 = last_event->vertex_handle();
CGAL_assertion((v1 == m_invalid_vertex) || (v1->degree() == 0));
if (v1 == m_invalid_vertex)
// Create the vertex to be associated with the left end of the curve.
v1 = m_arr_access.create_vertex (_point (last_event->point()));
v1 = m_arr_access.create_vertex(_point(last_event->point()));
// Check if the vertex to be associated with the right end of the curve has
// already been created.
Event* curr_event = this->current_event();
Vertex_handle v2 = curr_event->vertex_handle();
CGAL_assertion((v2 == m_invalid_vertex) || (v2->degree() == 0));
if (v2 == m_invalid_vertex)
// Create the vertex to be associated with the right end of the curve.
v2 = m_arr_access.create_vertex (_point (curr_event->point()));
v2 = m_arr_access.create_vertex(_point(curr_event->point()));
// Perform the insertion between the two (currently isolated) vertices in
// the interior of the current top face, as given by the helper class.
Halfedge_handle res =
m_arr_access.insert_in_face_interior_ex (m_helper.top_face(), _curve(cv),
m_arr_access.insert_in_face_interior_ex(m_helper.top_face(), _curve(cv),
ARR_LEFT_TO_RIGHT, v1, v2);
// Map the new halfedge to the indices list of all subcurves that lie
// below it.
if (sc->has_halfedge_indices())
{
if (sc->has_halfedge_indices()) {
CGAL_assertion(res->twin()->direction() == ARR_RIGHT_TO_LEFT);
Indices_list& list_ref = m_he_indices_table[res->twin()];
list_ref.clear();
@ -681,7 +621,7 @@ insert_in_face_interior (const X_monotone_curve_2& cv, Subcurve* sc)
}
// Notify the helper on the creation of the new halfedge.
m_helper.add_subcurve (res, sc);
m_helper.add_subcurve(res, sc);
return (res);
}
@ -691,14 +631,13 @@ insert_in_face_interior (const X_monotone_curve_2& cv, Subcurve* sc)
//
template <class Hlpr>
typename Arr_construction_sl_visitor<Hlpr>::Halfedge_handle
Arr_construction_sl_visitor<Hlpr>::insert_at_vertices
(const X_monotone_curve_2& cv,
Arr_construction_sl_visitor<Hlpr>::
insert_at_vertices(const X_monotone_curve_2& cv,
Halfedge_handle prev1,
Halfedge_handle prev2,
Subcurve* sc,
bool& new_face_created)
{
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "CGAL_CSLV insert_at_vertices:\ncurve:" << cv << std::endl;
if (!prev1->is_fictitious()) {
@ -730,8 +669,7 @@ Arr_construction_sl_visitor<Hlpr>::insert_at_vertices
std::pair< bool, bool > update(false, false);
#if 0
if ((prev1->is_on_inner_ccb() && prev1->is_on_inner_ccb() &&
prev1->inner_ccb() == prev2->inner_ccb())
||
prev1->inner_ccb() == prev2->inner_ccb()) ||
(!prev1->is_on_inner_ccb() && prev1->is_on_inner_ccb())) {
#else
// TODO improve this code!
@ -754,15 +692,12 @@ Arr_construction_sl_visitor<Hlpr>::insert_at_vertices
if (found1 && found2) {
#endif
update =
m_top_traits->face_update_upon_edge_insertion(
&(*prev1), &(*prev2), cv
);
m_top_traits->face_update_upon_edge_insertion(&(*prev1), &(*prev2), cv);
}
const bool swap_preds = update.second;
// TODO propagate update.first to _insert_at_vertices!
#else
const bool swap_preds =
m_helper.swap_predecessors (this->current_event());
const bool swap_preds = m_helper.swap_predecessors(this->current_event());
#endif
// Comment: In some topologies swap_preds is always false,
@ -782,27 +717,29 @@ Arr_construction_sl_visitor<Hlpr>::insert_at_vertices
#if 1
res = (swap_preds) ?
// if swapping prev2 will become outer of new split face (it it exists)
m_arr_access.insert_at_vertices_ex (prev2, _curve(cv), ARR_LEFT_TO_RIGHT, prev1->next(),
new_face_created, check_swapped_predecessors, false) :
m_arr_access.insert_at_vertices_ex(prev2, _curve(cv), ARR_LEFT_TO_RIGHT,
prev1->next(), new_face_created,
check_swapped_predecessors, false) :
// usually prev1 is outer of new split face (it it exists)
// order is determined by top-traits helper!
// "false" disallows swapping of prev1/preve2! ...
m_arr_access.insert_at_vertices_ex (prev1, _curve(cv), ARR_RIGHT_TO_LEFT, prev2->next(),
new_face_created, check_swapped_predecessors, false);
m_arr_access.insert_at_vertices_ex(prev1, _curve(cv), ARR_RIGHT_TO_LEFT,
prev2->next(), new_face_created,
check_swapped_predecessors, false);
// ... thus the value should now have changed
CGAL_assertion(!check_swapped_predecessors);
#else
res = m_arr_access.insert_at_vertices_ex (prev1, _curve(cv), ARR_RIGHT_TO_LEFT, prev2->next(),
new_face_created, check_swapped_predecessors);
res = m_arr_access.insert_at_vertices_ex(prev1, _curve(cv), ARR_RIGHT_TO_LEFT,
prev2->next(), new_face_created,
check_swapped_predecessors);
if (check_swapped_predecessors)
res = res->twin();
#endif
// Map the new halfedge to the indices list of all subcurves that lie
// below it.
if (sc->has_halfedge_indices())
{
if (sc->has_halfedge_indices()) {
Halfedge_handle he = res;
if (swap_preds)
@ -818,17 +755,16 @@ Arr_construction_sl_visitor<Hlpr>::insert_at_vertices
// Notify the helper on the creation of the new halfedge.
// Note that we do this before trying to relocate holes in the new
// face (if one is created).
m_helper.add_subcurve (res, sc);
m_helper.add_subcurve(res, sc);
if (new_face_created)
{
if (new_face_created) {
// TODO EBEB 2012-10-17 needs a tests for outer-outer insertion
// In case a new face has been created (pointed by the new halfedge
// we obtained), we have to examine the holes and isolated vertices
// in the existing face (pointed by the twin halfedge) and relocate
// the relevant features in the new face.
CGAL_assertion(res->face() != res->twin()->face());
this->relocate_in_new_face (res);
this->relocate_in_new_face(res);
}
return (res);
@ -839,8 +775,8 @@ Arr_construction_sl_visitor<Hlpr>::insert_at_vertices
//
template <class Hlpr>
typename Arr_construction_sl_visitor<Hlpr>::Halfedge_handle
Arr_construction_sl_visitor<Hlpr>::insert_from_right_vertex
(const X_monotone_curve_2& cv,
Arr_construction_sl_visitor<Hlpr>::
insert_from_right_vertex(const X_monotone_curve_2& cv,
Halfedge_handle prev,
Subcurve* sc)
{
@ -855,43 +791,22 @@ Arr_construction_sl_visitor<Hlpr>::insert_from_right_vertex
std::cout << "prevfac : " << &(*prev->face()) << std::endl;
#endif
// Check if the vertex to be associated with the left end of the curve has
// already been created.
Event *last_event = last_event_on_subcurve(sc);
Event* last_event = last_event_on_subcurve(sc);
Vertex_handle v = last_event->vertex_handle();
CGAL_assertion((v == m_invalid_vertex) || (v->degree() == 0));
if (v == m_invalid_vertex)
{
// Create the vertex to be associated with the left end of the curve.
v = m_arr_access.create_vertex (_point (last_event->point()));
}
else if (v->degree() > 0)
{
// In this case the left vertex v is a boundary vertex which already has
// some incident halfedges. We look for the predecessor halfedge and
// and insert the curve between two existing vertices.
Arr_parameter_space bx = last_event->parameter_space_in_x();
Arr_parameter_space by = last_event->parameter_space_in_y();
CGAL_assertion (bx != ARR_INTERIOR || by != ARR_INTERIOR);
Halfedge_handle l_prev = Halfedge_handle
(m_top_traits->locate_around_boundary_vertex (&(*v), _curve(cv),
ARR_MIN_END, bx, by));
bool dummy;
return (this->insert_at_vertices (cv, prev, l_prev, sc, dummy));
}
if (v == m_invalid_vertex)
v = m_arr_access.create_vertex(_point(last_event->point()));
// Insert the curve given its left vertex and the predecessor around the
// right vertex.
Halfedge_handle res =
m_arr_access.insert_from_vertex_ex (prev, _curve(cv), ARR_RIGHT_TO_LEFT, v);
m_arr_access.insert_from_vertex_ex(prev, _curve(cv), ARR_RIGHT_TO_LEFT, v);
// Map the new halfedge to the indices list of all subcurves that lie
// below it.
if (sc->has_halfedge_indices())
{
if (sc->has_halfedge_indices()) {
CGAL_assertion(res->direction() == ARR_RIGHT_TO_LEFT);
Indices_list& list_ref = m_he_indices_table[res];
list_ref.clear();
@ -899,7 +814,7 @@ Arr_construction_sl_visitor<Hlpr>::insert_from_right_vertex
}
// Notify the helper on the creation of the new halfedge.
m_helper.add_subcurve (res, sc);
m_helper.add_subcurve(res, sc);
return (res);
}
@ -910,7 +825,7 @@ Arr_construction_sl_visitor<Hlpr>::insert_from_right_vertex
template <class Hlpr>
typename Arr_construction_sl_visitor<Hlpr>::Halfedge_handle
Arr_construction_sl_visitor<Hlpr>::
insert_from_left_vertex (const X_monotone_curve_2& cv,
insert_from_left_vertex(const X_monotone_curve_2& cv,
Halfedge_handle prev,
Subcurve* sc)
{
@ -925,44 +840,22 @@ insert_from_left_vertex (const X_monotone_curve_2& cv,
std::cout << "prevfac : " << &(*prev->face()) << std::endl;
#endif
// Check if the vertex to be associated with the right end of the curve has
// already been created.
Event *curr_event = this->current_event();
Event* curr_event = this->current_event();
Vertex_handle v = curr_event->vertex_handle();
CGAL_assertion((v == m_invalid_vertex) || (v->degree() == 0));
if (v == m_invalid_vertex)
{
// Create the vertex to be associated with the right end of the curve.
v = m_arr_access.create_vertex (_point (curr_event->point()));
}
else if (v->degree() > 0)
{
// In this case the left vertex v is a boundary vertex which already has
// some incident halfedges. We look for the predecessor halfedge and
// and insert the curve from this right vertex.
Arr_parameter_space bx = curr_event->parameter_space_in_x();
Arr_parameter_space by = curr_event->parameter_space_in_y();
CGAL_assertion (bx != ARR_INTERIOR || by != ARR_INTERIOR);
Halfedge_handle r_prev = Halfedge_handle
(m_top_traits->locate_around_boundary_vertex (&(*v), _curve(cv),
ARR_MAX_END, bx, by)
);
bool dummy;
return (this->insert_at_vertices (cv, r_prev, prev, sc, dummy));
}
if (v == m_invalid_vertex)
v = m_arr_access.create_vertex(_point(curr_event->point()));
// Insert the curve given its right vertex and the predecessor around the
// left vertex.
Halfedge_handle res =
m_arr_access.insert_from_vertex_ex (prev, _curve(cv), ARR_LEFT_TO_RIGHT, v);
m_arr_access.insert_from_vertex_ex(prev, _curve(cv), ARR_LEFT_TO_RIGHT, v);
// Map the new halfedge to the indices list of all subcurves that lie
// below it.
if (sc->has_halfedge_indices())
{
if (sc->has_halfedge_indices()) {
CGAL_assertion(res->twin()->direction() == ARR_RIGHT_TO_LEFT);
Indices_list& list_ref = m_he_indices_table[res->twin()];
list_ref.clear();
@ -970,7 +863,7 @@ insert_from_left_vertex (const X_monotone_curve_2& cv,
}
// Notify the helper on the creation of the new halfedge.
m_helper.add_subcurve (res, sc);
m_helper.add_subcurve(res, sc);
return (res);
}
@ -981,7 +874,7 @@ insert_from_left_vertex (const X_monotone_curve_2& cv,
template <class Hlpr>
typename Arr_construction_sl_visitor<Hlpr>::Vertex_handle
Arr_construction_sl_visitor<Hlpr>::
insert_isolated_vertex (const Point_2& pt,
insert_isolated_vertex(const Point_2& pt,
Status_line_iterator /* iter */)
{
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
@ -990,16 +883,14 @@ insert_isolated_vertex (const Point_2& pt,
// Insert the isolated vertex in the interior of the current top face, as
// given by the helper class.
return (m_arr->insert_in_face_interior (_point(pt),
m_helper.top_face()));
return (m_arr->insert_in_face_interior(_point(pt), m_helper.top_face()));
}
//-----------------------------------------------------------------------------
// Reloacte holes and isolated vertices inside a newly created face.
//
template <class Hlpr>
void Arr_construction_sl_visitor<Hlpr>::
relocate_in_new_face (Halfedge_handle he)
void Arr_construction_sl_visitor<Hlpr>::relocate_in_new_face(Halfedge_handle he)
{
#if 0
std::cout << "CGAL_CSLV relocate" << std::endl;
@ -1016,11 +907,9 @@ relocate_in_new_face (Halfedge_handle he)
const Halfedge_handle invalid_he;
Vertex_handle v;
do
{
do {
// We are interested only in halfedges directed from right to left.
if (curr_he->direction() == ARR_LEFT_TO_RIGHT)
{
if (curr_he->direction() == ARR_LEFT_TO_RIGHT) {
curr_he = curr_he->next();
continue;
}
@ -1030,8 +919,7 @@ relocate_in_new_face (Halfedge_handle he)
const Indices_list& indices_list = const_he_indices_table[curr_he];
typename Indices_list::const_iterator itr;
for (itr = indices_list.begin(); itr != indices_list.end(); ++itr)
{
for (itr = indices_list.begin(); itr != indices_list.end(); ++itr) {
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "itr: " << *itr << std::endl;
std::cout << "m_sc_counter: " << m_sc_counter << std::endl;
@ -1049,29 +937,24 @@ relocate_in_new_face (Halfedge_handle he)
Halfedge_handle he_on_face = m_sc_he_table[*itr];
if(he_on_face == invalid_he)
{
if (he_on_face == invalid_he) {
// If the halfedge handle is invalis, then we have an index for an
// isolated vertex. Move this vertex to the new face, if necessary.
v = m_iso_verts_map[*itr];
CGAL_assertion(v != m_invalid_vertex);
if (v->face() != new_face)
{
m_arr_access.move_isolated_vertex (v->face(),
new_face,
v);
if (v->face() != new_face) {
m_arr_access.move_isolated_vertex(v->face(), new_face, v);
}
}
else
{
else {
// If necessary, move the hole that the halfedge belongs to into the
// new face.
if (he_on_face->twin()->face() != new_face &&
he_on_face->twin()->is_on_inner_ccb())
{
//std::cout << "move inner ccb " << std::endl;
m_arr_access.move_inner_ccb (he_on_face->twin()->face(),
m_arr_access.move_inner_ccb(he_on_face->twin()->face(),
new_face,
he_on_face->twin()->ccb());
@ -1086,8 +969,6 @@ relocate_in_new_face (Halfedge_handle he)
curr_he = curr_he->next();
} while(curr_he != he);
return;
}
//-----------------------------------------------------------------------------
@ -1095,20 +976,19 @@ relocate_in_new_face (Halfedge_handle he)
//
template <class Hlpr>
void Arr_construction_sl_visitor<Hlpr>::
_map_new_halfedge (unsigned int i, Halfedge_handle he)
_map_new_halfedge(unsigned int i, Halfedge_handle he)
{
#if CGAL_ARR_CONSTRUCTION_SL_VISITOR_VERBOSE
std::cout << "map " << i << " to " << he->curve() << " "
<< he->direction() << std::endl;
#endif
CGAL_assertion (i != 0);
if(i >= m_sc_he_table.size())
CGAL_assertion(i != 0);
if (i >= m_sc_he_table.size())
// Resize the index table if we reached it capacity.
m_sc_he_table.resize(2*i);
// Map the index to the given halfedge handle.
m_sc_he_table[i] = he;
return;
}
} //namespace CGAL