#include <Halfedge_data_structure_decorator.h>

Public Types
typedef _HDS	HDS

typedef _HDS	Halfedge_data_structure

typedef _HDS::Vertex	Vertex

typedef _HDS::Halfedge	Halfedge

typedef _HDS::Facet	Facet

typedef _HDS::Point	Point

typedef _HDS::Supports_vertex_point	Supports_vertex_point

typedef _HDS::Supports_vertex_halfedge	Supports_vertex_halfedge

typedef _HDS::Supports_halfedge_prev	Supports_halfedge_prev

typedef _HDS::Supports_halfedge_vertex	Supports_halfedge_vertex

typedef _HDS::Supports_halfedge_facet	Supports_halfedge_facet

typedef _HDS::Supports_facet_halfedge	Supports_facet_halfedge

typedef _HDS::Supports_removal	Supports_removal

Public Member Functions
Halfedge *	get_vertex_halfedge (Vertex *v) const

Vertex *	get_vertex (Halfedge *h) const

Halfedge *	get_prev (Halfedge *h) const

Halfedge *	find_prev (Halfedge *h) const

Halfedge *	find_prev_around_vertex (Halfedge *h) const

Facet *	get_facet (Halfedge *h) const

Halfedge *	get_facet_halfedge (Facet *f) const

const Halfedge *	get_vertex_halfedge (const Vertex *v) const

const Vertex *	get_vertex (const Halfedge *h) const

const Halfedge *	get_prev (const Halfedge *h) const

const Halfedge *	find_prev (const Halfedge *h) const

const Halfedge *	find_prev_around_vertex (const Halfedge *h) const

const Facet *	get_facet (const Halfedge *h) const

const Halfedge *	get_facet_halfedge (const Facet *f) const

Vertex *	new_vertex (HDS &hds) const

Vertex *	new_vertex (HDS &hds, const Point &p) const

Vertex *	new_vertex (HDS &hds, const Vertex *v) const

Facet *	new_facet (HDS &hds) const

Facet *	new_facet (HDS &hds, const Facet *f) const

Halfedge *	create_loop (HDS &hds)

Halfedge *	create_segment (HDS &hds)

void	delete_vertex (HDS &hds, Vertex *v)

void	delete_facet (HDS &hds, Facet *f)

void	close_tip (Halfedge *h) const

void	close_tip (Halfedge h, Vertex v) const

void	insert_tip (Halfedge h, Halfedge v) const

void	remove_tip (Halfedge *h) const

void	insert_halfedge (Halfedge h, Halfedge f) const

void	remove_halfedge (Halfedge *h) const

void	set_vertex_in_vertex_loop (Halfedge , Vertex , Tag_false)

void	set_vertex_in_vertex_loop (Halfedge h, Vertex v, Tag_true)

void	set_vertex_in_vertex_loop (Halfedge h, Vertex v)

void	set_facet_in_facet_loop (Halfedge , Facet , Tag_false)

void	set_facet_in_facet_loop (Halfedge h, Facet f, Tag_true)

void	set_facet_in_facet_loop (Halfedge h, Facet f)

Halfedge *	split_facet (HDS &hds, Halfedge h, Halfedge g)

Halfedge *	join_facet (HDS &hds, Halfedge *h)

Halfedge *	split_vertex (HDS &hds, Halfedge h, Halfedge g)

Halfedge *	join_vertex (HDS &hds, Halfedge *h)

Halfedge *	split_loop (HDS &hds, Halfedge h, Halfedge i, Halfedge *j)

Halfedge *	join_loop (HDS &hds, Halfedge h, Halfedge g)

Halfedge *	make_hole (HDS &hds, Halfedge *h)

Halfedge *	fill_hole (HDS &hds, Halfedge *h)

Halfedge *	add_facet_to_border (HDS &hds, Halfedge h, Halfedge g)

Halfedge *	flip_edge (Halfedge *h)

void	erase_facet (HDS &hds, Halfedge *h)

void	erase_connected_component (HDS &hds, Halfedge *h)

void	set_point (Vertex *v, const Point &p) const

void	set_point (Halfedge *h, const Point &p) const

void	set_vertex_halfedge (Vertex v, Halfedge g) const

void	set_vertex_halfedge (Halfedge *h) const

void	set_vertex (Halfedge h, Vertex v) const

void	set_prev (Halfedge h, Halfedge g) const

void	set_facet (Halfedge h, Facet f) const

void	set_facet_halfedge (Facet f, Halfedge g) const

void	set_facet_halfedge (Halfedge *h) const

Halfedge *	get_vertex_halfedge (Vertex *, Tag_false) const

Halfedge *	get_vertex_halfedge (Vertex *v, Tag_true) const

Vertex *	get_vertex (Halfedge *, Tag_false) const

Vertex *	get_vertex (Halfedge *h, Tag_true) const

Halfedge *	get_prev (Halfedge *, Tag_false) const

Halfedge *	get_prev (Halfedge *h, Tag_true) const

Halfedge *	find_prev (Halfedge *h, Tag_true) const

Halfedge *	find_prev (Halfedge *h, Tag_false) const

Halfedge *	find_prev_around_vertex (Halfedge *h, Tag_true) const

Halfedge *	find_prev_around_vertex (Halfedge *h, Tag_false) const

Facet *	get_facet (Halfedge *, Tag_false) const

Facet *	get_facet (Halfedge *h, Tag_true) const

Halfedge *	get_facet_halfedge (Facet *, Tag_false) const

Halfedge *	get_facet_halfedge (Facet *f, Tag_true) const

const Halfedge *	get_vertex_halfedge (const Vertex *, Tag_false) const

const Halfedge *	get_vertex_halfedge (const Vertex *v, Tag_true) const

const Vertex *	get_vertex (const Halfedge *, Tag_false) const

const Vertex *	get_vertex (const Halfedge *h, Tag_true) const

const Halfedge *	get_prev (const Halfedge *, Tag_false) const

const Halfedge *	get_prev (const Halfedge *h, Tag_true) const

const Halfedge *	find_prev (const Halfedge *h, Tag_true) const

const Halfedge *	find_prev (const Halfedge *h, Tag_false) const

const Halfedge *	find_prev_around_vertex (const Halfedge *h, Tag_true) const

const Halfedge *	find_prev_around_vertex (const Halfedge *h, Tag_false) const

const Facet *	get_facet (const Halfedge *, Tag_false) const

const Facet *	get_facet (const Halfedge *h, Tag_true) const

const Halfedge *	get_facet_halfedge (const Facet *, Tag_false) const

const Halfedge *	get_facet_halfedge (const Facet *f, Tag_true) const

Vertex *	new_vertex (HDS &, Tag_false) const

Vertex *	new_vertex (HDS &hds, Tag_true) const

Vertex *	new_vertex (HDS &, const Point &, Tag_false) const

Vertex *	new_vertex (HDS &hds, const Point &p, Tag_true) const

Vertex *	new_vertex (HDS &, const Vertex *, Tag_false) const

Vertex *	new_vertex (HDS &hds, const Vertex *v, Tag_true) const

Facet *	new_facet (HDS &, Tag_false) const

Facet *	new_facet (HDS &hds, Tag_true) const

Facet *	new_facet (HDS &, const Facet *, Tag_false) const

Facet *	new_facet (HDS &hds, const Facet *f, Tag_true) const

void	delete_vertex (HDS &, Vertex *, Tag_false)

void	delete_vertex (HDS &hds, Vertex *v, Tag_true)

void	delete_facet (HDS &, Facet *, Tag_false)

void	delete_facet (HDS &hds, Facet *f, Tag_true)

void	set_point (Vertex *, const Point &, Tag_false) const

void	set_point (Vertex *v, const Point &p, Tag_true) const

void	set_point (Halfedge *, const Point &, Tag_false) const

void	set_point (Halfedge *h, const Point &p, Tag_true) const

void	set_vertex_halfedge (Vertex , Halfedge , Tag_false) const

void	set_vertex_halfedge (Vertex v, Halfedge g, Tag_true) const

void	set_vertex_halfedge (Halfedge , Halfedge , Tag_false) const

void	set_vertex_halfedge (Halfedge h, Halfedge g, Tag_true) const

void	set_vertex (Halfedge , Vertex , Tag_false) const

void	set_vertex (Halfedge h, Vertex v, Tag_true) const

void	set_prev (Halfedge , Halfedge , Tag_false) const

void	set_prev (Halfedge h, Halfedge g, Tag_true) const

void	set_facet (Halfedge , Facet , Tag_false) const

void	set_facet (Halfedge h, Facet f, Tag_true) const

void	set_facet_halfedge (Facet , Halfedge , Tag_false) const

void	set_facet_halfedge (Facet f, Halfedge g, Tag_true) const

void	set_facet_halfedge (Halfedge , Halfedge , Tag_false) const

void	set_facet_halfedge (Halfedge h, Halfedge g, Tag_true) const

bool	normalized_border_is_valid (const _HDS &hds, bool verb=false) const

bool	is_valid (const _HDS &hds, bool verb=false, int level=0) const

void	reorient_facet (Halfedge *first)

void	inside_out (_HDS &hds, Tag_false)

void	inside_out (_HDS &hds, Tag_true)

void	inside_out (_HDS &hds)

Protected Types
typedef std::vector< Halfedge * >	HVector

Protected Member Functions
void	make_hole (HDS &, Halfedge *, Tag_false)

void	fill_hole (HDS &, Halfedge *, Tag_false)

void	make_hole (HDS &hds, Halfedge *h, Tag_true)

void	fill_hole (HDS &hds, Halfedge *h, Tag_true)

void	erase_facet (HDS &, Halfedge *, Tag_false)

void	erase_facet (HDS &hds, Halfedge *h, Tag_true)

void	erase_connected_component_vertex (HDS &hds, Halfedge *h, Tag_false)

void	erase_connected_component_vertex (HDS &hds, Halfedge *h, Tag_true)

void	erase_connected_component_vertex (HDS &hds, Halfedge *h)

void	erase_connected_component_face_cycle (HDS &hds, Halfedge *h, HVector &stack)

Detailed Description

template<class _HDS>
class Halfedge_data_structure_decorator< _HDS >

Definition at line 69 of file Halfedge_data_structure_decorator.h.

Member Typedef Documentation

typedef _HDS::Facet Facet

Definition at line 87 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Halfedge Halfedge

Definition at line 86 of file Halfedge_data_structure_decorator.h.

typedef _HDS Halfedge_data_structure

Definition at line 84 of file Halfedge_data_structure_decorator.h.

typedef _HDS HDS

Definition at line 83 of file Halfedge_data_structure_decorator.h.

typedef std::vector<Halfedge*> HVector

protected

Definition at line 789 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Point Point

Definition at line 90 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Supports_facet_halfedge Supports_facet_halfedge

Definition at line 106 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Supports_halfedge_facet Supports_halfedge_facet

Definition at line 104 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Supports_halfedge_prev Supports_halfedge_prev

Definition at line 100 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Supports_halfedge_vertex Supports_halfedge_vertex

Definition at line 102 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Supports_removal Supports_removal

Definition at line 108 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Supports_vertex_halfedge Supports_vertex_halfedge

Definition at line 98 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Supports_vertex_point Supports_vertex_point

Definition at line 96 of file Halfedge_data_structure_decorator.h.

typedef _HDS::Vertex Vertex

Definition at line 85 of file Halfedge_data_structure_decorator.h.

Member Function Documentation

Halfedge* add_facet_to_border	(	HDS &	hds,
		Halfedge *	h,
		Halfedge *	g
	)

inline

Definition at line 671 of file Halfedge_data_structure_decorator.h.

References CGAL_precondition, Halfedge_data_structure_decorator< _HDS >::fill_hole(), Halfedge_data_structure_decorator< _HDS >::insert_tip(), and Halfedge::is_border().

                                                                        {
         // creates a new facet from `hds' within the hole incident to h
         // and g by connecting the tip of g with the tip of h with a new
         // halfedge from `hds' and filling this separated part of the hole
         // with a new facet from `hds'. Returns the new halfedge incident
         // to the new facet. Precondition: `h != NULL', `g != NULL',
         // `h->is_border()', `g->is_border()' and g can be reached along
         // the same hole starting with h.
         CGAL_precondition( h != 0);
         CGAL_precondition( g != 0);
         CGAL_precondition( h->is_border());
         CGAL_precondition( g->is_border());
         Halfedge* hh = hds.new_edge();
         insert_tip( hh, h);
         insert_tip( hh->opposite(), g);
         fill_hole( hds, g);
         return hh;
     }

Here is the call graph for this function:

void close_tip ( Halfedge * h ) const

inline

Definition at line 293 of file Halfedge_data_structure_decorator.h.

References Halfedge::opposite(), and Halfedge_data_structure_decorator< _HDS >::set_prev().

Referenced by Halfedge_data_structure_decorator< _HDS >::split_loop().

                                        {
         // makes `h->opposite()' the successor of h.
         h->set_next( h->opposite());
         set_prev( h->opposite(), h);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void close_tip	(	Halfedge *	h,
		Vertex *	v
	)		const

inline

Definition at line 299 of file Halfedge_data_structure_decorator.h.

References Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::set_prev(), and Halfedge_data_structure_decorator< _HDS >::set_vertex().

                                                   {
         // makes `h->opposite()' the successor of h and sets the vertex to
         // v.
         h->set_next( h->opposite());
         set_prev( h->opposite(), h);
         set_vertex( h, v);
     }

Here is the call graph for this function:

Halfedge* create_loop ( HDS & hds )

inline

Definition at line 239 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_vertex(), Halfedge_data_structure_decorator< _HDS >::new_facet(), Halfedge_data_structure_decorator< _HDS >::new_vertex(), Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::set_facet(), Halfedge_data_structure_decorator< _HDS >::set_facet_halfedge(), Halfedge_data_structure_decorator< _HDS >::set_prev(), Halfedge_data_structure_decorator< _HDS >::set_vertex(), and Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge().

                                     {
         // returns a halfedge from a newly created loop in `hds'
         // consisting of a single closed edge, one vertex and two facets
         // (if supported respectively).
         Halfedge* h = hds.new_edge();
         h->set_next( h);
         h->opposite()->set_next( h->opposite());
         set_prev( h, h);
         set_prev( h->opposite(), h->opposite());
         set_vertex( h, new_vertex(hds));
         set_vertex( h->opposite(), get_vertex(h));
         set_facet( h, new_facet(hds));
         set_facet( h->opposite(), new_facet(hds));
         set_facet_halfedge( h);
         set_facet_halfedge( h->opposite());
         set_vertex_halfedge( h);
         return h;
     }

Here is the call graph for this function:

Halfedge* create_segment ( HDS & hds )

inline

Definition at line 258 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_facet(), Halfedge_data_structure_decorator< _HDS >::new_facet(), Halfedge_data_structure_decorator< _HDS >::new_vertex(), Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::set_facet(), Halfedge_data_structure_decorator< _HDS >::set_facet_halfedge(), Halfedge_data_structure_decorator< _HDS >::set_prev(), Halfedge_data_structure_decorator< _HDS >::set_vertex(), and Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge().

                                        {
         // returns a halfedge from a newly created segment in `hds'
         // consisting of a single open edge, two vertices and one facet
         // (if supported respectively).
         Halfedge* h = hds.new_edge();
         h->set_next( h->opposite());
         h->opposite()->set_next( h);
         set_prev( h, h->opposite());
         set_prev( h->opposite(), h);
         set_vertex( h, new_vertex(hds));
         set_vertex( h->opposite(), new_vertex(hds));
         set_facet( h, new_facet(hds));
         set_facet( h->opposite(), get_facet(h));
         set_facet_halfedge( h);
         set_vertex_halfedge( h);
         set_vertex_halfedge( h->opposite());
         return h;
     }

Here is the call graph for this function:

void delete_facet	(	HDS &	hds,
		Facet *	f
	)

inline

Definition at line 285 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::erase_connected_component_face_cycle(), Halfedge_data_structure_decorator< _HDS >::join_facet(), and Halfedge_data_structure_decorator< _HDS >::join_loop().

                                           {
         // removes the facet f if facets are supported.
         delete_facet( hds, f, Supports_halfedge_facet());
     }

Here is the caller graph for this function:

void delete_facet	(	HDS &	,
		Facet *	,
		Tag_false
	)

inline

Definition at line 1047 of file Halfedge_data_structure_decorator.h.

1047 {}

void delete_facet	(	HDS &	hds,
		Facet *	f,
		Tag_true
	)

inline

Definition at line 1048 of file Halfedge_data_structure_decorator.h.

                                                     {
         hds.delete_facet( f);
     }

void delete_vertex	(	HDS &	hds,
		Vertex *	v
	)

inline

Definition at line 280 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::erase_facet(), Halfedge_data_structure_decorator< _HDS >::join_loop(), and Halfedge_data_structure_decorator< _HDS >::join_vertex().

                                             {
         // removes the vertex v if vertices are supported.
         delete_vertex( hds, v, Supports_halfedge_vertex());
     }

Here is the caller graph for this function:

void delete_vertex	(	HDS &	,
		Vertex *	,
		Tag_false
	)

inline

Definition at line 1042 of file Halfedge_data_structure_decorator.h.

1042 {}

void delete_vertex	(	HDS &	hds,
		Vertex *	v,
		Tag_true
	)

inline

Definition at line 1043 of file Halfedge_data_structure_decorator.h.

                                                       {
         hds.delete_vertex( v);
     }

void erase_connected_component	(	HDS &	hds,
		Halfedge *	h
	)

inline

Definition at line 813 of file Halfedge_data_structure_decorator.h.

References Assert_compile_time_tag(), CGAL_assertion, Halfedge_data_structure_decorator< _HDS >::erase_connected_component_face_cycle(), Halfedge::next(), and Halfedge::opposite().

                                                            {
         Assert_compile_time_tag( Tag_true(), Supports_removal());
         HVector stack;
         // Algorithm: The next() pointer is used as visited tag
         //     for a graph search. If the next pointer of an halfedge
         //     or its opposite halfedge is set to 0, this edge has already
         //     been visited and must not be put on the stack again.
         // Initializing: Cycle through the face-cycle of h and put
         //     all opposite halfedges on the stack. Put h->opposite()
         //     on the stack. Note that even if the face cycle of h looks
         //     ugly ( e.g. h->opposite() is also in the cycle), neither
         //     h nor h->opposite() will be put on the stack. If
         //     h->opposite() is in the cycle, when h will be popped from
         //     the stack it will be immediately deleted.
         // Loop invariant: For each edge h on the stack h->opposite()->
         //     next() == NULL.
         // Looping: For each edge h on the stack, if h->next() is
         //     not already equal to NULL, cycle through the face-cycle
         //     of h and put all opposite halfedges on the stack.
         //     Delete h.
         // Where: Cycle through a face means: If h->facet() != NULL
         //     delete h->facet() and set all facet handles to NULL.
         //     Loop through the halfedges g around the facet, call
         //     erase_connected_component_vertex for each g, push
         //     g->opposite() on the stack if g->opposite()->next()
         //     is not already NULL. This implies that h->opposite()
         //     is not put on the stack again.
         erase_connected_component_face_cycle( hds, h, stack);
         stack.push_back( h->opposite());
         while ( ! stack.empty()) {
             h = stack.back();
             stack.pop_back();
             CGAL_assertion( h->opposite()->next() == 0);
             if ( h->next() != 0)
                 erase_connected_component_face_cycle( hds, h, stack);
             hds.delete_edge( h);
         }
     }

Here is the call graph for this function:

void erase_connected_component_face_cycle	(	HDS &	hds,
		Halfedge *	h,
		HVector &	stack
	)

inlineprotected

Definition at line 790 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::delete_facet(), Halfedge_data_structure_decorator< _HDS >::erase_connected_component_vertex(), Halfedge_data_structure_decorator< _HDS >::get_facet(), Halfedge::next(), Halfedge::opposite(), and Halfedge_data_structure_decorator< _HDS >::set_facet_in_facet_loop().

Referenced by Halfedge_data_structure_decorator< _HDS >::erase_connected_component().

                                                                  {
           // Delete incident facet and set all incidences to 0.
           if ( get_facet(h) != 0) {
               delete_facet( hds, get_facet(h));
               set_facet_in_facet_loop( h, 0);
           }
           // Cycle around facet, delete incident vertices, push new
           // edges on the stack and mark edges as visited.
           erase_connected_component_vertex( hds, h);
           Halfedge* g = h->next();
           h->set_next(0);
           while (g != h) {
               erase_connected_component_vertex( hds, g);
               if ( g->opposite()->next() != 0)
                   stack.push_back( g->opposite());
               Halfedge* gg = g->next();
               g->set_next(0);
               g = gg;
           }
       }

Here is the call graph for this function:

Here is the caller graph for this function:

void erase_connected_component_vertex	(	HDS &	hds,
		Halfedge *	h,
		Tag_false
	)

inlineprotected

Definition at line 768 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::erase_connected_component_face_cycle(), and Halfedge_data_structure_decorator< _HDS >::erase_connected_component_vertex().

769 {}

Here is the caller graph for this function:

void erase_connected_component_vertex	(	HDS &	hds,
		Halfedge *	h,
		Tag_true
	)

inlineprotected

Definition at line 770 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::set_vertex_in_vertex_loop().

                                                        {
           // Erases the the vertex incident to h and sets all references
           // from halfedges around this vertex to NULL,
           // if the incident vertex handle is not already equal to
           // NULL. It is used to erase vertices as soon
           // as an vertex is encountered in the graph traversal. At this
           // point of the graph traversal the halfedge cycle around the
           // vertex is still closed. Lateron it will be broken.
           if ( h->vertex() != NULL) {
               hds.delete_vertex( h->vertex());
               set_vertex_in_vertex_loop( h, NULL);
           }
       }

Here is the call graph for this function:

void erase_connected_component_vertex	(	HDS &	hds,
		Halfedge *	h
	)

inlineprotected

Definition at line 784 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::erase_connected_component_vertex().

                                                                     {
           erase_connected_component_vertex( hds, h,
                                             Supports_halfedge_vertex());
       }

Here is the call graph for this function:

void erase_facet	(	HDS &	,
		Halfedge *	,
		Tag_false
	)

inlineprotected

Definition at line 720 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::erase_facet().

720 {}

Here is the caller graph for this function:

void erase_facet	(	HDS &	hds,
		Halfedge *	h,
		Tag_true
	)

inlineprotected

Definition at line 721 of file Halfedge_data_structure_decorator.h.

References Assert_compile_time_tag(), CGAL_assertion, CGAL_assertion_code, CGAL_precondition, Halfedge_data_structure_decorator< _HDS >::delete_vertex(), Halfedge_data_structure_decorator< _HDS >::find_prev_around_vertex(), Halfedge_data_structure_decorator< _HDS >::get_vertex(), Halfedge::is_border(), Halfedge::next(), Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::remove_tip(), Halfedge_data_structure_decorator< _HDS >::set_facet(), and Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge().

                                                         {
         Assert_compile_time_tag( Tag_true(), Supports_removal());
         CGAL_precondition( h != 0);
         CGAL_precondition( ! h->is_border());
         hds.delete_facet( h->facet());
         CGAL_assertion_code( std::size_t termination_count = 0;)
         Halfedge* end = h;
         do {
             CGAL_assertion( ++termination_count != 0);
             set_facet( h, 0);
             Halfedge* g = h->next();
             bool h_tag = h->opposite()->is_border();
             bool g_tag = g->opposite()->is_border();
             if ( h_tag && g_tag && g->opposite()->next() == h->opposite()){
                 delete_vertex( hds, get_vertex(h));
                 if ( h != end)
                     hds.delete_edge(h);
             } else {
                 if ( g_tag) {
                     set_vertex_halfedge(g->opposite()->next()->opposite());
                     remove_tip(h);
                 }
                 if ( h_tag) {
                     set_vertex_halfedge(h->next()->opposite());
                     remove_tip( find_prev_around_vertex( h->opposite()));
                     if ( h != end)
                         hds.delete_edge(h);
                 }
             }
             h = g;
         } while ( h != end);
         if ( h->opposite()->is_border())
             hds.delete_edge(h);
     }

Here is the call graph for this function:

void erase_facet	(	HDS &	hds,
		Halfedge *	h
	)

inline

Definition at line 757 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::erase_facet().

                                              {
         // removes the facet incident to `h' from `hds' and changes all
         // halfedges incident to the facet into border edges or removes
         // them from the polyhedral surface if they were already border
         // edges. See `make_hole(h)' for a more specialized variant.
         // Precondition: `h != NULL'. If facets are supported,
         // `Supports_removal' must be equivalent to `Tag_true'.
         erase_facet( hds, h, Supports_halfedge_facet());
     }

Here is the call graph for this function:

void fill_hole	(	HDS &	,
		Halfedge *	,
		Tag_false
	)

inlineprotected

Definition at line 635 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::add_facet_to_border(), and Halfedge_data_structure_decorator< _HDS >::fill_hole().

635 {}

Here is the caller graph for this function:

void fill_hole	(	HDS &	hds,
		Halfedge *	h,
		Tag_true
	)

inlineprotected

Definition at line 645 of file Halfedge_data_structure_decorator.h.

References CGAL_precondition, Halfedge::is_border(), Halfedge_data_structure_decorator< _HDS >::new_facet(), Halfedge_data_structure_decorator< _HDS >::set_facet_halfedge(), and Halfedge_data_structure_decorator< _HDS >::set_facet_in_facet_loop().

                                                      {
         CGAL_precondition( h != 0);
         CGAL_precondition( h->is_border());
         Facet* f = new_facet(hds);
         set_facet_in_facet_loop( h, f);
         set_facet_halfedge( h);
     }

Here is the call graph for this function:

Halfedge* fill_hole	(	HDS &	hds,
		Halfedge *	h
	)

inline

Definition at line 663 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::fill_hole().

                                                 {
         // fill a hole with a new created facet. Makes all border
         // halfedges of the hole denoted by h incident to the new facet.
         // Returns h. Precondition: `h.is_border()'.
         fill_hole( hds, h, Supports_halfedge_facet());
         return h;
     }

Here is the call graph for this function:

Halfedge* find_prev ( Halfedge * h ) const

inline

Definition at line 137 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::find_prev(), Halfedge_data_structure_decorator< _HDS >::join_facet(), and Halfedge_data_structure_decorator< _HDS >::join_vertex().

                                             {
         // returns the previous halfedge of h. Uses the `prev()' method if
         // supported or performs a search around the facet using `next()'.
         return find_prev( h, Supports_halfedge_prev());
     }

Here is the caller graph for this function:

const Halfedge* find_prev ( const Halfedge * h ) const

inline

Definition at line 181 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::find_prev().

                                                         {
         // returns the previous halfedge of h. Uses the `prev()' method if
         // supported or performs a search around the facet using `next()'.
         return find_prev( h, Supports_halfedge_prev());
     }

Here is the call graph for this function:

Halfedge* find_prev	(	Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 920 of file Halfedge_data_structure_decorator.h.

References Halfedge::prev().

920 { return h->prev(); }

Halfedge::prev

Halfedge prev() const

Get the previous halfedge of its owner element.

Definition: Manifold_2.h:460

Here is the call graph for this function:

Halfedge* find_prev	(	Halfedge *	h,
		Tag_false
	)		const

inline

Definition at line 921 of file Halfedge_data_structure_decorator.h.

References Halfedge::next().

                                                       {
         Halfedge* g = h;
         while ( g->next() != h)
             g = g->next();
         return g;
     }

Here is the call graph for this function:

const Halfedge* find_prev	(	const Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 969 of file Halfedge_data_structure_decorator.h.

References Halfedge::prev().

969 { return h->prev(); }

Halfedge::prev

Halfedge prev() const

Get the previous halfedge of its owner element.

Definition: Manifold_2.h:460

Here is the call graph for this function:

const Halfedge* find_prev	(	const Halfedge *	h,
		Tag_false
	)		const

inline

Definition at line 971 of file Halfedge_data_structure_decorator.h.

References Halfedge::next().

                                                    {
         const Halfedge* g = h;
         while ( g->next() != h)
             g = g->next();
         return g;
     }

Here is the call graph for this function:

Halfedge* find_prev_around_vertex ( Halfedge * h ) const

inline

Definition at line 143 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::erase_facet(), and Halfedge_data_structure_decorator< _HDS >::find_prev_around_vertex().

                                                           {
         // returns the previous halfedge of h. Uses the `prev()' method if
         // supported or performs a search around the vertex using `next()'.
         return find_prev_around_vertex( h, Supports_halfedge_prev());
     }

Here is the caller graph for this function:

const Halfedge* find_prev_around_vertex ( const Halfedge * h ) const

inline

Definition at line 187 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::find_prev_around_vertex().

                                                                       {
         // returns the previous halfedge of h. Uses the `prev()' method if
         // supported or performs a search around the vertex using `next()'.
         return find_prev_around_vertex( h, Supports_halfedge_prev());
     }

Here is the call graph for this function:

Halfedge* find_prev_around_vertex	(	Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 928 of file Halfedge_data_structure_decorator.h.

References Halfedge::prev().

                                                                    {
         return h->prev();
     }

Here is the call graph for this function:

Halfedge* find_prev_around_vertex	(	Halfedge *	h,
		Tag_false
	)		const

inline

Definition at line 931 of file Halfedge_data_structure_decorator.h.

References Halfedge::next(), and Halfedge::opposite().

                                                                     {
         Halfedge* g = h->opposite();
         while ( g->next() != h)
             g = g->next()->opposite();
         return g;
     }

Here is the call graph for this function:

const Halfedge* find_prev_around_vertex	(	const Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 978 of file Halfedge_data_structure_decorator.h.

References Halfedge::prev().

                                                              {
         return h->prev();
     }

Here is the call graph for this function:

const Halfedge* find_prev_around_vertex	(	const Halfedge *	h,
		Tag_false
	)		const

inline

Definition at line 982 of file Halfedge_data_structure_decorator.h.

References Halfedge::next(), and Halfedge::opposite().

                                                               {
         const Halfedge* g = h->opposite();
         while ( g->next() != h)
             g = g->next()->opposite();
         return g;
     }

Here is the call graph for this function:

Halfedge* flip_edge ( Halfedge * h )

inline

Definition at line 690 of file Halfedge_data_structure_decorator.h.

References CGAL_postcondition, CGAL_precondition, Halfedge_data_structure_decorator< _HDS >::insert_tip(), Halfedge::next(), Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::remove_tip(), Halfedge_data_structure_decorator< _HDS >::set_facet(), Halfedge_data_structure_decorator< _HDS >::set_facet_halfedge(), and Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge().

                                       {
         // Left rotate of edge.
         // Precond: both incident facets are triangles.
         CGAL_precondition( h == h->next()->next()->next());
         CGAL_precondition( h->opposite() ==
                     h->opposite()->next()->next()->next());
         Halfedge* hprev = h->next()->next();
         Halfedge* gprev = h->opposite()->next()->next();
         remove_tip( hprev);
         remove_tip( gprev);
         set_facet_halfedge(  hprev);
         set_facet_halfedge(  gprev);
         set_vertex_halfedge( hprev);
         set_vertex_halfedge( gprev);
         set_facet( hprev->next(), hprev->facet());
         set_facet( gprev->next(), gprev->facet());
         hprev = hprev->next();
         gprev = gprev->next();
         insert_tip( h, gprev);
         insert_tip( h->opposite(), hprev);
         CGAL_postcondition( h == h->next()->next()->next());
         CGAL_postcondition( h->opposite() ==
                      h->opposite()->next()->next()->next());
         return h;
     }

Here is the call graph for this function:

Facet* get_facet ( Halfedge * h ) const

inline

Definition at line 149 of file Halfedge_data_structure_decorator.h.

Referenced by Polyhedron_incremental_builder_3< HDS >::add_vertex_to_facet(), Halfedge_data_structure_decorator< _HDS >::create_segment(), Halfedge_data_structure_decorator< _HDS >::erase_connected_component_face_cycle(), Halfedge_data_structure_decorator< _HDS >::get_facet(), Halfedge_data_structure_decorator< _HDS >::insert_halfedge(), Halfedge_data_structure_decorator< _HDS >::join_facet(), Halfedge_data_structure_decorator< _HDS >::join_loop(), Polyhedron_incremental_builder_3< HDS >::lookup_halfedge(), Polyhedron_incremental_builder_3< HDS >::lookup_hole(), Halfedge_data_structure_using_vector< V, H, F >::pointer_update(), and Halfedge_data_structure_decorator< _HDS >::split_facet().

                                          {
         // returns the incident facet of h if supported, `NULL' otherwise.
         return get_facet( h, Supports_halfedge_facet());
     }

Here is the caller graph for this function:

const Facet* get_facet ( const Halfedge * h ) const

inline

Definition at line 193 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_facet().

                                                      {
         // returns the incident facet of h if supported, `NULL' otherwise.
         return get_facet( h, Supports_halfedge_facet());
     }

Here is the call graph for this function:

Facet* get_facet	(	Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 938 of file Halfedge_data_structure_decorator.h.

938 { return NULL;}

Facet* get_facet	(	Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 939 of file Halfedge_data_structure_decorator.h.

939 { return h->facet();}

const Facet* get_facet	(	const Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 991 of file Halfedge_data_structure_decorator.h.

991 { return NULL;}

const Facet* get_facet	(	const Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 993 of file Halfedge_data_structure_decorator.h.

993 { return h->facet();}

Halfedge* get_facet_halfedge ( Facet * f ) const

inline

Definition at line 154 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::get_facet_halfedge().

                                                   {
         // returns the incident halfedge of f if supported, `NULL'
         // otherwise.
         return get_facet_halfedge( f, Supports_facet_halfedge());
     }

Here is the caller graph for this function:

const Halfedge* get_facet_halfedge ( const Facet * f ) const

inline

Definition at line 198 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_facet_halfedge().

                                                               {
         // returns the incident halfedge of f if supported, `NULL'
         // otherwise.
         return get_facet_halfedge( f, Supports_facet_halfedge());
     }

Here is the call graph for this function:

Halfedge* get_facet_halfedge	(	Facet *	,
		Tag_false
	)		const

inline

Definition at line 941 of file Halfedge_data_structure_decorator.h.

                                                              {
         return NULL;
     }

Halfedge* get_facet_halfedge	(	Facet *	f,
		Tag_true
	)		const

inline

Definition at line 944 of file Halfedge_data_structure_decorator.h.

                                                             {
         return f->halfedge();
     }

const Halfedge* get_facet_halfedge	(	const Facet *	,
		Tag_false
	)		const

inline

Definition at line 996 of file Halfedge_data_structure_decorator.h.

                                                          {
         return NULL;
     }

const Halfedge* get_facet_halfedge	(	const Facet *	f,
		Tag_true
	)		const

inline

Definition at line 1000 of file Halfedge_data_structure_decorator.h.

                                                         {
         return f->halfedge();
     }

Halfedge* get_prev ( Halfedge * h ) const

inline

Definition at line 131 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::get_prev(), and Halfedge_data_structure_using_vector< V, H, F >::pointer_update().

                                            {
         // returns the previous halfedge of h if supported, `NULL'
         // otherwise.
         return get_prev( h, Supports_halfedge_prev());
     }

Here is the caller graph for this function:

const Halfedge* get_prev ( const Halfedge * h ) const

inline

Definition at line 175 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_prev().

                                                        {
         // returns the previous halfedge of h if supported, `NULL'
         // otherwise.
         return get_prev( h, Supports_halfedge_prev());
     }

Here is the call graph for this function:

Halfedge* get_prev	(	Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 917 of file Halfedge_data_structure_decorator.h.

917 {return NULL;}

Halfedge* get_prev	(	Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 918 of file Halfedge_data_structure_decorator.h.

References Halfedge::prev().

918 {return h->prev();}

Halfedge::prev

Halfedge prev() const

Get the previous halfedge of its owner element.

Definition: Manifold_2.h:460

Here is the call graph for this function:

const Halfedge* get_prev	(	const Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 964 of file Halfedge_data_structure_decorator.h.

964 { return NULL; }

const Halfedge* get_prev	(	const Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 966 of file Halfedge_data_structure_decorator.h.

References Halfedge::prev().

966 { return h->prev(); }

Halfedge::prev

Halfedge prev() const

Get the previous halfedge of its owner element.

Definition: Manifold_2.h:460

Here is the call graph for this function:

Vertex* get_vertex ( Halfedge * h ) const

inline

Definition at line 125 of file Halfedge_data_structure_decorator.h.

                                            {
         // returns the incident vertex of h if supported, `NULL'
         // otherwise.
         return get_vertex( h, Supports_halfedge_vertex());
     }

Here is the caller graph for this function:

const Vertex* get_vertex ( const Halfedge * h ) const

inline

Definition at line 169 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_vertex().

                                                        {
         // returns the incident vertex of h if supported, `NULL'
         // otherwise.
         return get_vertex( h, Supports_halfedge_vertex());
     }

Here is the call graph for this function:

Vertex* get_vertex	(	Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 912 of file Halfedge_data_structure_decorator.h.

912 { return NULL;}

Vertex* get_vertex	(	Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 913 of file Halfedge_data_structure_decorator.h.

                                                       {
         return h->vertex();
     }

const Vertex* get_vertex	(	const Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 959 of file Halfedge_data_structure_decorator.h.

959 { return NULL; }

const Vertex* get_vertex	(	const Halfedge *	h,
		Tag_true
	)		const

inline

Definition at line 961 of file Halfedge_data_structure_decorator.h.

961 { return h->vertex(); }

Halfedge* get_vertex_halfedge ( Vertex * v ) const

inline

Definition at line 119 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::get_vertex_halfedge().

                                                     {
         // returns the incident halfedge of v if supported, `NULL'
         // otherwise.
         return get_vertex_halfedge( v, Supports_vertex_halfedge());
     }

Here is the caller graph for this function:

const Halfedge* get_vertex_halfedge ( const Vertex * v ) const

inline

Definition at line 163 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_vertex_halfedge().

                                                                 {
         // returns the incident halfedge of v if supported, `NULL'
         // otherwise.
         return get_vertex_halfedge( v, Supports_vertex_halfedge());
     }

Here is the call graph for this function:

Halfedge* get_vertex_halfedge	(	Vertex *	,
		Tag_false
	)		const

inline

Definition at line 905 of file Halfedge_data_structure_decorator.h.

                                                               {
         return NULL;
     }

Halfedge* get_vertex_halfedge	(	Vertex *	v,
		Tag_true
	)		const

inline

Definition at line 908 of file Halfedge_data_structure_decorator.h.

                                                              {
         return v->halfedge();
     }

const Halfedge* get_vertex_halfedge	(	const Vertex *	,
		Tag_false
	)		const

inline

Definition at line 952 of file Halfedge_data_structure_decorator.h.

952 { return NULL; }

const Halfedge* get_vertex_halfedge	(	const Vertex *	v,
		Tag_true
	)		const

inline

Definition at line 954 of file Halfedge_data_structure_decorator.h.

                                                          {
         return v->halfedge();
     }

void insert_halfedge	(	Halfedge *	h,
		Halfedge *	f
	)		const

inline

Definition at line 327 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_facet(), Halfedge::next(), Halfedge_data_structure_decorator< _HDS >::set_facet(), and Halfedge_data_structure_decorator< _HDS >::set_prev().

Referenced by Halfedge_data_structure_decorator< _HDS >::split_vertex().

                                                           {
         // inserts the halfedge h between f and `f->next()'. The facet of
         // h will be the one f points to if facets are supported.
         h->set_next( f->next());
         f->set_next( h);
         set_prev( h->next(), h);
         set_prev( h, f);
         set_facet( h, get_facet( f));
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void insert_tip	(	Halfedge *	h,
		Halfedge *	v
	)		const

inline

Definition at line 307 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_vertex(), Halfedge::next(), Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::set_prev(), Halfedge_data_structure_decorator< _HDS >::set_vertex(), and v.

Referenced by Halfedge_data_structure_decorator< _HDS >::add_facet_to_border(), Halfedge_data_structure_decorator< _HDS >::flip_edge(), Halfedge_data_structure_decorator< _HDS >::split_facet(), and Halfedge_data_structure_decorator< _HDS >::split_loop().

                                                      {
         // inserts the tip of the edge h into the halfedges around the
         // vertex pointed to by v. `h->opposite()' is the new successor of
         // v and `h->next()' will be set to `v->next()'. The vertex of h
         // will be the one v points to if vertices are supported.
         h->set_next( v->next());
         v->set_next( h->opposite());
         set_prev( h->next(), h);
         set_prev( h->opposite(), v);
         set_vertex( h, get_vertex( v));
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void inside_out	(	_HDS &	hds,
		Tag_false
	)

Definition at line 1395 of file Halfedge_data_structure_decorator.h.

References CGAL_assertion, d, and Halfedge::next().

Referenced by Halfedge_data_structure_decorator< _HDS >::inside_out().

                                   {
     typedef typename _HDS::Halfedge_iterator Halfedge_iterator;
     Halfedge_iterator begin = hds.halfedges_begin();
     Halfedge_iterator end   = hds.halfedges_end();
     for( ; begin != end; ++begin) {
         // Define the halfedge with the `smallest' pointer
         // value as the one that is used to reorient the facet.
         Halfedge* h = &*begin;
         bool is_min = true;
         Halfedge* c = h;
         Halfedge* d = c;
         do {
             CGAL_assertion( c != NULL);
             if ( h > c)
                 is_min = false;
             c = c->next();
         } while ( c != d && is_min);
         if ( is_min)
             reorient_facet( h);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void inside_out	(	_HDS &	hds,
		Tag_true
	)

Definition at line 1420 of file Halfedge_data_structure_decorator.h.

                                  {
     typedef typename _HDS::Halfedge_iterator Halfedge_iterator;
     typedef typename _HDS::Facet_iterator    Facet_iterator;
     Facet_iterator begin = hds.facets_begin();
     Facet_iterator end   = hds.facets_end();
     for( ; begin != end; ++begin)
         reorient_facet( begin->halfedge());
     // Note: A border edge is now parallel to its opposite edge.
     // We scan all border edges for this property. If it holds, we
     // reorient the associated hole and search again until no border
     // edge with that property exists any longer. Then, all holes are
     // reoriented.
     Halfedge_iterator first = hds.halfedges_begin();
     Halfedge_iterator last  = hds.halfedges_end();
     for( ; first != last; ++first) {
         if ( first->is_border() &&
              first->vertex() == first->opposite()->vertex())
             reorient_facet( &*first);
     }
 }

void inside_out ( _HDS & hds )

inline

Definition at line 1112 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::inside_out().

                                 {
         inside_out( hds, Supports_facet_halfedge());
     }

Here is the call graph for this function:

bool is_valid	(	const _HDS &	hds,
		bool	verb = `false`,
		int	level = `0`
	)		const

Definition at line 1172 of file Halfedge_data_structure_decorator.h.

References check_tag(), n, Halfedge::next(), Halfedge::opposite(), and v.

                                                        {
     // checks the combinatorial consistency.
     typedef typename _HDS::Halfedge_const_iterator Halfedge_const_iterator;
     typedef typename _HDS::Vertex_const_iterator   Vertex_const_iterator;
     typedef typename _HDS::Facet_const_iterator    Facet_const_iterator;
     typedef typename _HDS::Size                    Size;
     typedef typename _HDS::Supports_halfedge_prev  Supports_halfedge_prev;
     typedef typename _HDS::Supports_halfedge_vertex
         Supports_halfedge_vertex;
     typedef typename _HDS::Supports_vertex_halfedge
         Supports_vertex_halfedge;
     typedef typename _HDS::Supports_halfedge_facet
         Supports_halfedge_facet;
     typedef typename _HDS::Supports_facet_halfedge
         Supports_facet_halfedge;
 
     Verbose_ostream verr(verb);
     verr << "begin Halfedge_data_structure_decorator<HDS>::is_valid("
             " verb=true, level = " << level << "):" << std::endl;
 
     bool valid = ( 1 != (hds.size_of_halfedges() & 1));
     if ( ! valid)
         verr << "number of halfedges is odd." << std::endl;
 
     // All halfedges.
     Halfedge_const_iterator begin = hds.halfedges_begin();
     Halfedge_const_iterator end   = hds.halfedges_end();
     Size  n = 0;
     Size nb = 0;
     for( ; valid && (begin != end); begin++) {
         verr << "halfedge " << n << std::endl;
         if ( begin->is_border())
             verr << "    is border halfedge" << std::endl;
         // Pointer integrity.
         valid = valid && ( begin->next() != NULL);
         valid = valid && ( begin->opposite() != NULL);
         if ( ! valid) {
             verr << "    pointer integrity corrupted (ptr==NULL)."
                  << std::endl;
             break;
         }
         // opposite integrity.
         valid = valid && ( begin->opposite() != &*begin);
         valid = valid && ( begin->opposite()->opposite() == &*begin);
         if ( ! valid) {
             verr << "    opposite pointer integrity corrupted."
                  << std::endl;
             break;
         }
         // previous integrity.
         valid = valid && ( ! check_tag( Supports_halfedge_prev()) ||
                            get_prev(begin->next()) == &*begin);
         if ( ! valid) {
             verr << "    previous pointer integrity corrupted."
                  << std::endl;
             break;
         }
         if ( level > 0) {
             // vertex integrity.
             valid = valid && ( ! check_tag( Supports_halfedge_vertex())
                                || get_vertex( &*begin) != NULL);
             valid = valid && ( get_vertex( &*begin) ==
                                get_vertex( begin->next()->opposite()));
             if ( ! valid) {
                 verr << "    vertex pointer integrity corrupted."
                      << std::endl;
                 break;
             }
             // facet integrity.
             valid = valid && ( ! check_tag( Supports_halfedge_facet())
                      || begin->is_border() || get_facet( &*begin) != NULL);
             valid = valid && ( get_facet( &*begin) ==
                         get_facet( begin->next()));
             if ( ! valid) {
                 verr << "    facet pointer integrity corrupted."
                      << std::endl;
                 break;
             }
         }
         ++n;
         if ( begin->is_border())
             ++nb;
     }
     verr << "summe border halfedges (2*nb) = " << 2 * nb << std::endl;
     if ( valid && n != hds.size_of_halfedges())
         verr << "counting halfedges failed." << std::endl;
     if ( valid && level >= 4 && (nb != hds.size_of_border_halfedges()))
         verr << "counting border halfedges failed." << std::endl;
     valid = valid && ( n  == hds.size_of_halfedges());
     valid = valid && ( level < 4 ||
                        (nb == hds.size_of_border_halfedges()));
 
     // All vertices.
     Vertex_const_iterator vbegin = hds.vertices_begin();
     Vertex_const_iterator vend   = hds.vertices_end();
     Size v = 0;
     n = 0;
     for( ; valid && (vbegin != vend); ++vbegin) {
         verr << "vertex " << v << std::endl;
         // Pointer integrity.
         if ( get_vertex_halfedge( &*vbegin) != NULL)
             valid = valid && ( ! check_tag(
                 Supports_halfedge_vertex()) ||
                 get_vertex( get_vertex_halfedge( &*vbegin)) == &*vbegin);
         else
             valid = valid && (! check_tag(
                 Supports_vertex_halfedge()));
         if ( ! valid) {
             verr << "    halfedge pointer in vertex corrupted."
                  << std::endl;
             break;
         }
         // cycle-around-vertex test.
         const Halfedge* h = get_vertex_halfedge( &*vbegin);
         if ( h) {
             const Halfedge* g = h;
             do {
                 verr << "    halfedge " << n << std::endl;
                 ++n;
                 h = h->next()->opposite();
                 valid = valid && ( n <= hds.size_of_halfedges() && n != 0);
             } while ( valid && (h != g));
         }
         ++v;
     }
     if ( valid && v != hds.size_of_vertices())
         verr << "counting vertices failed." << std::endl;
     if ( valid && level >= 2 && ( check_tag( Supports_vertex_halfedge())
          && n  != hds.size_of_halfedges()))
         verr << "counting halfedges via vertices failed." << std::endl;
     valid = valid && ( v == hds.size_of_vertices());
     valid = valid && ( level < 2 ||
                        ! check_tag( Supports_vertex_halfedge()) ||
                        n  == hds.size_of_halfedges());
 
     // All facets.
     Facet_const_iterator fbegin = hds.facets_begin();
     Facet_const_iterator fend   = hds.facets_end();
     Size f = 0;
     n = 0;
     for( ; valid && (fbegin != fend); ++fbegin) {
         verr << "facet " << f << std::endl;
         // Pointer integrity.
         if ( get_facet_halfedge( &*fbegin) != NULL)
             valid = valid && ( ! check_tag(
                 Supports_halfedge_facet()) ||
                 get_facet( get_facet_halfedge( &*fbegin)) == &*fbegin);
         else
             valid = valid && (! check_tag(
                 Supports_facet_halfedge()) || begin->is_border());
         if ( ! valid) {
             verr << "    halfedge pointer in facet corrupted."
                  << std::endl;
             break;
         }
         // cycle-around-facet test.
         const Halfedge* h = get_facet_halfedge( &*fbegin);
         if ( h) {
             const Halfedge* g = h;
             do {
                 verr << "    halfedge " << n << std::endl;
                 ++n;
                 h = h->next();
                 valid = valid && ( n <= hds.size_of_halfedges() && n != 0);
             } while ( valid && (h != g));
         }
         ++f;
     }
     if ( valid && f != hds.size_of_facets())
         verr << "counting facets failed." << std::endl;
     if ( valid && level >= 3 && check_tag( Supports_facet_halfedge()) &&
          n + nb  != hds.size_of_halfedges())
         verr << "counting halfedges via facets failed." << std::endl;
     valid = valid && ( f == hds.size_of_facets());
     valid = valid && ( level < 3 ||
                        ! check_tag( Supports_facet_halfedge()) ||
                        n + nb  == hds.size_of_halfedges());
 
     if ( level >= 4) {
         verr << "level 4: normalized_border_is_valid( verbose = true)"
              << std::endl;
         valid = valid && ( normalized_border_is_valid( hds, verb));
     }
     verr << "end of Halfedge_data_structure_decorator<HDS>::"
             "is_valid(): structure is " << ( valid ? "valid." :
             "NOT VALID.") << std::endl;
     return valid;
 }

Here is the call graph for this function:

Halfedge* join_facet	(	HDS &	hds,
		Halfedge *	h
	)

inline

Definition at line 404 of file Halfedge_data_structure_decorator.h.

References Assert_compile_time_tag(), CGAL_assertion, CGAL_assertion_code, Halfedge_data_structure_decorator< _HDS >::delete_facet(), Halfedge_data_structure_decorator< _HDS >::find_prev(), Halfedge_data_structure_decorator< _HDS >::get_facet(), Halfedge::next(), Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::remove_tip(), Halfedge_data_structure_decorator< _HDS >::set_facet(), Halfedge_data_structure_decorator< _HDS >::set_facet_halfedge(), and Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge().

                                                  {
         // join the two facets incident to h. The facet incident to
         // `h->opposite()' gets removed. Both facets might be holes.
         // Returns the predecessor of h. The invariant `join_facet(
         // split_facet( h, g))' returns h and keeps `hds'
         // unchanged. The time is proportional to the size of the facet
         // removed and the time to compute `h.prev()'. Precondition:
         // `HDS' supports removal of facets.
         Assert_compile_time_tag( Tag_true(), Supports_removal());
         Halfedge* hprev = find_prev( h);
         Halfedge* gprev = find_prev( h->opposite());
         remove_tip( hprev);
         remove_tip( gprev);
         hds.delete_edge( h);
         if ( get_facet( gprev) != 0)
             delete_facet( hds, get_facet( gprev));
         h = hprev;
         // 'half' of the halfedges have their correct facets.
         // Here we do the remaining halfedges.
         CGAL_assertion_code( std::size_t termination_count = 0;)
         while ( h != gprev) {
             CGAL_assertion( ++termination_count != 0);
             h = h->next();
             set_facet( h, get_facet( hprev));
         }
         if ( get_facet( hprev) != 0)
             set_facet_halfedge( hprev);
         set_vertex_halfedge( hprev);
         set_vertex_halfedge( gprev);
         return hprev;
     }

Here is the call graph for this function:

Halfedge* join_loop	(	HDS &	hds,
		Halfedge *	h,
		Halfedge *	g
	)

inline

Definition at line 580 of file Halfedge_data_structure_decorator.h.

                                                              {
         // glues the boundary of two facets together. Both facets and the
         // vertices of the facet loop g gets removed. Returns h. The
         // invariant `join_loop( h, split_loop( h, i, j))' returns h and
         // keeps `hds' unchanged. Precondition: `HDS' supports
         // removal of vertices and facets. The facets denoted by h and g
         // are different and have have equal size.
         Assert_compile_time_tag( Tag_true(), Supports_removal());
         CGAL_precondition( get_facet(h) == 0
                            || get_facet(h) != get_facet(g));
         if ( get_facet(h) != 0)
             delete_facet( hds, get_facet(h));
         if ( get_facet(g) != 0)
             delete_facet( hds, get_facet(g));
         Halfedge* hi = h;
         Halfedge* gi = g;
         CGAL_assertion_code( std::size_t termination_count = 0;)
         do {
             CGAL_assertion( ++termination_count != 0);
             Halfedge* hii = hi;
             Halfedge* gii = gi;
             hi = hi->next();
             // gi = find_prev(gi); // Replaced by search around vertex.
             set_facet( hii, get_facet( gii->opposite()));
             set_facet_halfedge( hii);
             delete_vertex( hds, get_vertex( gii->opposite()));
             if ( gii->opposite()->next()->opposite()->next() == gii) {
                 gi = gii->opposite()->next()->opposite();
             } else {
                 hii->set_next( gii->opposite()->next());
                 set_prev( hii->next(), hii);
                 gii = gii->opposite()->next()->opposite();
                 set_vertex( gii, get_vertex(hii));
                 while ( gii->next()->opposite()->next() != gi) {
                     CGAL_assertion( ++termination_count != 0);
                     gii = gii->next()->opposite();
                     set_vertex( gii, get_vertex(hii));
                 }
                 gi = gii->next()->opposite();
                 gii->set_next( hi);
                 set_prev( gii->next(), gii);
             }
         } while ( hi != h);
         CGAL_assertion( gi == g);
         do {
             Halfedge* gii = gi;
             gi = gi->next();
             hds.delete_edge( gii);
         } while ( gi != g);
         return h;
     }

Here is the call graph for this function:

Halfedge* join_vertex	(	HDS &	hds,
		Halfedge *	h
	)

inline

Definition at line 452 of file Halfedge_data_structure_decorator.h.

References Assert_compile_time_tag(), CGAL_assertion, CGAL_assertion_code, Halfedge_data_structure_decorator< _HDS >::delete_vertex(), Halfedge_data_structure_decorator< _HDS >::find_prev(), Halfedge_data_structure_decorator< _HDS >::get_vertex(), Halfedge::is_border(), Halfedge::next(), Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::remove_halfedge(), Halfedge_data_structure_decorator< _HDS >::set_facet_halfedge(), Halfedge_data_structure_decorator< _HDS >::set_vertex(), and Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge().

                                                   {
         // join the two vertices incident to h. The vertex denoted by
         // `h->opposite()' gets removed. Returns the predecessor of h. The
         // invariant `join_vertex( split_vertex( h, g))' returns h and
         // keeps `hds' unchanged. The time is proportional to the
         // degree of the vertex removed and the time to compute `h.prev()'
         // . Precondition: `HDS' supports removal of vertices.
         Assert_compile_time_tag( Tag_true(), Supports_removal());
         Halfedge* hprev = find_prev( h->opposite());
         Halfedge* gprev = find_prev( h);
         remove_halfedge( hprev);
         remove_halfedge( gprev);
         hds.delete_edge( h);
         delete_vertex( hds, get_vertex( gprev));
         // 'half' of the halfedges have their correct vertex.
         // Here we do the remaining halfedges.
         h = hprev;
         CGAL_assertion_code( std::size_t termination_count = 0;)
         while ( h != gprev) {
             CGAL_assertion( ++termination_count != 0);
             h = h->next()->opposite();
             set_vertex( h, get_vertex( hprev));
         }
         set_vertex_halfedge( hprev);
         if ( ! hprev->is_border())
             set_facet_halfedge(  hprev);
         if ( ! gprev->is_border())
             set_facet_halfedge(  gprev);
         return hprev;
     }

Here is the call graph for this function:

void make_hole	(	HDS &	,
		Halfedge *	,
		Tag_false
	)

inlineprotected

Definition at line 634 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::make_hole().

634 {}

Here is the caller graph for this function:

void make_hole	(	HDS &	hds,
		Halfedge *	h,
		Tag_true
	)

inlineprotected

Definition at line 637 of file Halfedge_data_structure_decorator.h.

References Assert_compile_time_tag(), CGAL_precondition, Halfedge::is_border(), and Halfedge_data_structure_decorator< _HDS >::set_facet_in_facet_loop().

                                                      {
         Assert_compile_time_tag( Tag_true(), Supports_removal());
         CGAL_precondition( h != 0);
         CGAL_precondition( ! h->is_border());
         hds.delete_facet( h->facet());
         set_facet_in_facet_loop( h, 0);
     }

Here is the call graph for this function:

Halfedge* make_hole	(	HDS &	hds,
		Halfedge *	h
	)

inline

Definition at line 655 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::make_hole().

                                                 {
         // removes incident facet and makes all halfedges incident to the
         // facet to border edges. Returns h. Precondition: `HDS'
         // supports removal of facets. `! h.is_border()'.
         make_hole( hds, h, Supports_halfedge_facet());
         return h;
     }

Here is the call graph for this function:

Facet* new_facet ( HDS & hds ) const

inline

Definition at line 225 of file Halfedge_data_structure_decorator.h.

Referenced by Polyhedron_incremental_builder_3< HDS >::begin_facet(), Halfedge_data_structure_decorator< _HDS >::create_loop(), Halfedge_data_structure_decorator< _HDS >::create_segment(), Halfedge_data_structure_decorator< _HDS >::fill_hole(), Halfedge_data_structure_decorator< _HDS >::new_facet(), Halfedge_data_structure_decorator< _HDS >::split_facet(), and Halfedge_data_structure_decorator< _HDS >::split_loop().

                                       {
         // returns a new facet from `hds' if facets are supported, `NULL'
         // otherwise.
         return new_facet( hds, Supports_halfedge_facet());
     }

Here is the caller graph for this function:

Facet* new_facet	(	HDS &	hds,
		const Facet *	f
	)		const

inline

Definition at line 231 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::new_facet().

                                                       {
         // returns a copy of f from `hds' if facets
         // are supported, `NULL' otherwise.
         return new_facet( hds, f, Supports_halfedge_facet());
     }

Here is the call graph for this function:

Facet* new_facet	(	HDS &	,
		Tag_false
	)		const

inline

Definition at line 1026 of file Halfedge_data_structure_decorator.h.

1026 { return NULL;}

Facet* new_facet	(	HDS &	hds,
		Tag_true
	)		const

inline

Definition at line 1027 of file Halfedge_data_structure_decorator.h.

                                                  {
         return hds.new_facet();
     }

Facet* new_facet	(	HDS &	,
		const Facet *	,
		Tag_false
	)		const

inline

Definition at line 1031 of file Halfedge_data_structure_decorator.h.

                                                                  {
         return NULL;
     }

Facet* new_facet	(	HDS &	hds,
		const Facet *	f,
		Tag_true
	)		const

inline

Definition at line 1034 of file Halfedge_data_structure_decorator.h.

                                                                  {
         return hds.new_facet(f);
     }

Vertex* new_vertex ( HDS & hds ) const

inline

Definition at line 207 of file Halfedge_data_structure_decorator.h.

Referenced by Polyhedron_incremental_builder_3< HDS >::add_vertex(), Halfedge_data_structure_decorator< _HDS >::create_loop(), Halfedge_data_structure_decorator< _HDS >::create_segment(), Halfedge_data_structure_decorator< _HDS >::new_vertex(), Halfedge_data_structure_decorator< _HDS >::split_loop(), and Halfedge_data_structure_decorator< _HDS >::split_vertex().

                                         {
         // returns a new vertex from `hds' if vertices are supported,
         // `NULL' otherwise.
         return new_vertex( hds, Supports_halfedge_vertex());
     }

Here is the caller graph for this function:

Vertex* new_vertex	(	HDS &	hds,
		const Point &	p
	)		const

inline

Definition at line 213 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::new_vertex().

                                                         {
         // returns a new vertex from `hds' initialized to p if vertices
         // are supported, `NULL' otherwise.
         return new_vertex( hds, p, Supports_halfedge_vertex());
     }

Here is the call graph for this function:

Vertex* new_vertex	(	HDS &	hds,
		const Vertex *	v
	)		const

inline

Definition at line 219 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::new_vertex().

                                                          {
         // returns a copy of v from `hds' if vertices
         // are supported, `NULL' otherwise.
         return new_vertex( hds, v, Supports_halfedge_vertex());
     }

Here is the call graph for this function:

Vertex* new_vertex	(	HDS &	,
		Tag_false
	)		const

inline

Definition at line 1007 of file Halfedge_data_structure_decorator.h.

1007 { return NULL;}

Vertex* new_vertex	(	HDS &	hds,
		Tag_true
	)		const

inline

Definition at line 1008 of file Halfedge_data_structure_decorator.h.

                                                    {
         return hds.new_vertex();
     }

Vertex* new_vertex	(	HDS &	,
		const Point &	,
		Tag_false
	)		const

inline

Definition at line 1012 of file Halfedge_data_structure_decorator.h.

                                                                    {
         return NULL;
     }

Vertex* new_vertex	(	HDS &	hds,
		const Point &	p,
		Tag_true
	)		const

inline

Definition at line 1015 of file Halfedge_data_structure_decorator.h.

                                                                    {
         return hds.new_vertex(p);
     }

Vertex* new_vertex	(	HDS &	,
		const Vertex *	,
		Tag_false
	)		const

inline

Definition at line 1019 of file Halfedge_data_structure_decorator.h.

                                                                    {
         return NULL;
     }

Vertex* new_vertex	(	HDS &	hds,
		const Vertex *	v,
		Tag_true
	)		const

inline

Definition at line 1022 of file Halfedge_data_structure_decorator.h.

                                                                    {
         return hds.new_vertex(v);
     }

bool normalized_border_is_valid	(	const _HDS &	hds,
		bool	verb = `false`
	)		const

Definition at line 1120 of file Halfedge_data_structure_decorator.h.

                                                               {
     // checks whether all non-border edges precedes the border edges.
     typedef typename _HDS::Halfedge_const_iterator Halfedge_const_iterator;
     typedef typename _HDS::Size                    Size;
     bool valid = true;
     Verbose_ostream verr(verb);
     verr << "begin Halfedge_data_structure_decorator<HDS>::"
             "normalized_border_is_valid( verb=true):" << std::endl;
 
     Halfedge_const_iterator e = hds.halfedges_begin();
     Size count = 0;
     while( e != hds.halfedges_end() && ! e->is_border() && !
            e->opposite()->is_border()) {
         ++e;
         ++e;
         ++count;
     }
     verr << "    non-border edges: " << count << std::endl;
     if ( e != hds.border_halfedges_begin()) {
         verr << "    first border edge does not start at "
                 "border_halfedges_begin()" << std::endl;
         valid = false;
     } else {
         count = 0;
         while( valid && e != hds.halfedges_end() &&
                e->opposite()->is_border()) {
             ++e;
             ++e;
             ++count;
         }
         verr << "    border     edges: " << count << std::endl;
         verr << "    total      edges: " << hds.size_of_halfedges()/2
              << std::endl;
         if ( e != hds.halfedges_end()) {
             if ( e->is_border()) {
                 verr << "    border edge " << count
                      << ": wrong orientation." << std::endl;
             }
             verr << "    the sum of full + border equals not total edges."
                  << std::endl;
             valid = false;
         }
     }
     verr << "end of Halfedge_data_structure_decorator<HDS>::"
             "normalized_border_is_valid(): structure is "
          << ( valid ? "valid." : "NOT VALID.") << std::endl;
     return valid;
 }

void remove_halfedge ( Halfedge * h ) const

inline

Definition at line 337 of file Halfedge_data_structure_decorator.h.

References Halfedge::next(), and Halfedge_data_structure_decorator< _HDS >::set_prev().

Referenced by Halfedge_data_structure_decorator< _HDS >::join_vertex().

                                              {
         // removes `h->next()' from the halfedge circle around the facet
         // pointed to by h. The new successor of h will be `h->next()
         // ->next()'.
         h->set_next( h->next()->next());
         set_prev( h->next(), h);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

void remove_tip ( Halfedge * h ) const

inline

Definition at line 319 of file Halfedge_data_structure_decorator.h.

References Halfedge::next(), Halfedge::opposite(), and Halfedge_data_structure_decorator< _HDS >::set_prev().

Referenced by Halfedge_data_structure_decorator< _HDS >::erase_facet(), Halfedge_data_structure_decorator< _HDS >::flip_edge(), and Halfedge_data_structure_decorator< _HDS >::join_facet().

                                         {
         // removes `h->next()->opposite()' from the halfedge circle around
         // the vertex pointed to by h. The new successor of h will be
         // `h->next()->opposite()->next()'.
         h->set_next( h->next()->opposite()->next());
         set_prev( h->next(), h);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

CGAL_MEDIUM_INLINE void reorient_facet ( Halfedge * first )

Definition at line 1365 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_vertex(), Halfedge::next(), Halfedge_data_structure_decorator< _HDS >::set_prev(), Halfedge_data_structure_decorator< _HDS >::set_vertex(), and Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge().

                                  {
     if ( first == NULL)
         return;
     Halfedge_data_structure_decorator<_HDS> decorator;
     Halfedge* last  = first;
     Halfedge* prev  = first;
     Halfedge* start = first;
     first = first->next();
     Vertex*  new_v = decorator.get_vertex( start);
     while (first != last) {
         Vertex*  tmp_v = decorator.get_vertex( first);
         decorator.set_vertex( first, new_v);
         decorator.set_vertex_halfedge( first);
         new_v = tmp_v;
         Halfedge* next = first->next();
         first->set_next( prev);
         decorator.set_prev( first, next);
         prev  = first;
         first = next;
     }
     decorator.set_vertex( start, new_v);
     decorator.set_vertex_halfedge( start);
     Halfedge* next = start->next();
     start->set_next( prev);
     decorator.set_prev( start, next);
 }

Here is the call graph for this function:

void set_facet	(	Halfedge *	h,
		Facet *	f
	)		const

inline

Definition at line 885 of file Halfedge_data_structure_decorator.h.

                                                  {
         // sets the incident facet of h to f.
         set_facet(h, f, Supports_halfedge_facet());
     }

Here is the caller graph for this function:

void set_facet	(	Halfedge *	,
		Facet *	,
		Tag_false
	)		const

inline

Definition at line 1084 of file Halfedge_data_structure_decorator.h.

1084 {}

void set_facet	(	Halfedge *	h,
		Facet *	f,
		Tag_true
	)		const

inline

Definition at line 1085 of file Halfedge_data_structure_decorator.h.

                                                             {
         h->set_facet(f);
     }

void set_facet_halfedge	(	Facet *	f,
		Halfedge *	g
	)		const

inline

Definition at line 890 of file Halfedge_data_structure_decorator.h.

                                                           {
         // sets the incident halfedge of f to g.
         set_facet_halfedge( f, g, Supports_facet_halfedge());
     }

Here is the caller graph for this function:

void set_facet_halfedge ( Halfedge * h ) const

inline

Definition at line 895 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::set_facet_halfedge().

                                                 {
         // sets the incident halfedge of the facet incident to h to h.
         set_facet_halfedge( h, h, Supports_halfedge_facet());
     }

Here is the call graph for this function:

void set_facet_halfedge	(	Facet *	,
		Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 1089 of file Halfedge_data_structure_decorator.h.

1089 {}

void set_facet_halfedge	(	Facet *	f,
		Halfedge *	g,
		Tag_true
	)		const

inline

Definition at line 1090 of file Halfedge_data_structure_decorator.h.

                                                                      {
         f->set_halfedge(g);
     }

void set_facet_halfedge	(	Halfedge *	,
		Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 1094 of file Halfedge_data_structure_decorator.h.

1094 {}

void set_facet_halfedge	(	Halfedge *	h,
		Halfedge *	g,
		Tag_true
	)		const

inline

Definition at line 1095 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::set_facet_halfedge().

                                                                        {
         set_facet_halfedge( h->facet(), g);
     }

Here is the call graph for this function:

void set_facet_in_facet_loop	(	Halfedge *	,
		Facet *	,
		Tag_false
	)

inline

Definition at line 365 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::erase_connected_component_face_cycle(), Halfedge_data_structure_decorator< _HDS >::fill_hole(), Halfedge_data_structure_decorator< _HDS >::make_hole(), Halfedge_data_structure_decorator< _HDS >::set_facet_in_facet_loop(), and Halfedge_data_structure_decorator< _HDS >::split_facet().

365 {}

Here is the caller graph for this function:

void set_facet_in_facet_loop	(	Halfedge *	h,
		Facet *	f,
		Tag_true
	)

inline

Definition at line 366 of file Halfedge_data_structure_decorator.h.

References CGAL_assertion, CGAL_assertion_code, and Halfedge::next().

                                                                    {
         CGAL_assertion_code( std::size_t termination_count = 0;)
         Halfedge* end = h;
         do {
             CGAL_assertion( ++termination_count != 0);
             h->set_facet( f);
             h = h->next();
         } while ( h != end);
     }

Here is the call graph for this function:

void set_facet_in_facet_loop	(	Halfedge *	h,
		Facet *	f
	)

inline

Definition at line 376 of file Halfedge_data_structure_decorator.h.

References CGAL_precondition, and Halfedge_data_structure_decorator< _HDS >::set_facet_in_facet_loop().

                                                          {
         // Loops around the facet incident to h and sets all facet
         // pointers to f. Precondition: `h != NULL'.
         CGAL_precondition( h != 0);
         set_facet_in_facet_loop( h, f, Supports_halfedge_facet());
     }

Here is the call graph for this function:

void set_point	(	Vertex *	v,
		const Point &	p
	)		const

inline

Definition at line 855 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::set_point().

                                                      {
         set_point( v, p, Supports_vertex_point());
         // sets the point of v to p.
     }

Here is the caller graph for this function:

void set_point	(	Halfedge *	h,
		const Point &	p
	)		const

inline

Definition at line 860 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::set_point().

                                                        {
         // sets the point of the vertex incident to h to p.
         set_point( h, p, Supports_halfedge_vertex());
     }

Here is the call graph for this function:

void set_point	(	Vertex *	,
		const Point &	,
		Tag_false
	)		const

inline

Definition at line 1054 of file Halfedge_data_structure_decorator.h.

1054 {}

void set_point	(	Vertex *	v,
		const Point &	p,
		Tag_true
	)		const

inline

Definition at line 1055 of file Halfedge_data_structure_decorator.h.

                                                                 {
         v->point() = p;
     }

void set_point	(	Halfedge *	,
		const Point &	,
		Tag_false
	)		const

inline

Definition at line 1059 of file Halfedge_data_structure_decorator.h.

1059 {}

void set_point	(	Halfedge *	h,
		const Point &	p,
		Tag_true
	)		const

inline

Definition at line 1060 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::set_point().

                                                                   {
         set_point( h->vertex(), p);
     }

Here is the call graph for this function:

void set_prev	(	Halfedge *	h,
		Halfedge *	g
	)		const

inline

Definition at line 880 of file Halfedge_data_structure_decorator.h.

                                                    {
         // sets the previous link of h to g.
         set_prev( h, g, Supports_halfedge_prev());
     }

Here is the caller graph for this function:

void set_prev	(	Halfedge *	,
		Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 1079 of file Halfedge_data_structure_decorator.h.

1079 {}

void set_prev	(	Halfedge *	h,
		Halfedge *	g,
		Tag_true
	)		const

inline

Definition at line 1080 of file Halfedge_data_structure_decorator.h.

                                                               {
         h->set_prev( g);
     }

void set_vertex	(	Halfedge *	h,
		Vertex *	v
	)		const

inline

Definition at line 875 of file Halfedge_data_structure_decorator.h.

                                                    {
         // sets the incident vertex of h to v.
         set_vertex(h, v, Supports_halfedge_vertex());
     }

Here is the caller graph for this function:

void set_vertex	(	Halfedge *	,
		Vertex *	,
		Tag_false
	)		const

inline

Definition at line 1074 of file Halfedge_data_structure_decorator.h.

1074 {}

void set_vertex	(	Halfedge *	h,
		Vertex *	v,
		Tag_true
	)		const

inline

Definition at line 1075 of file Halfedge_data_structure_decorator.h.

                                                               {
         h->set_vertex(v);
     }

void set_vertex_halfedge	(	Vertex *	v,
		Halfedge *	g
	)		const

inline

Definition at line 865 of file Halfedge_data_structure_decorator.h.

                                                             {
         // sets the incident halfedge of v to g.
         set_vertex_halfedge( v, g, Supports_vertex_halfedge());
     }

Here is the caller graph for this function:

void set_vertex_halfedge ( Halfedge * h ) const

inline

Definition at line 870 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge().

                                                  {
         // sets the incident halfedge of the vertex incident to h to h.
         set_vertex_halfedge( h, h, Supports_halfedge_vertex());
     }

Here is the call graph for this function:

void set_vertex_halfedge	(	Vertex *	,
		Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 1064 of file Halfedge_data_structure_decorator.h.

1064 {}

void set_vertex_halfedge	(	Vertex *	v,
		Halfedge *	g,
		Tag_true
	)		const

inline

Definition at line 1065 of file Halfedge_data_structure_decorator.h.

                                                                        {
         v->set_halfedge(g);
     }

void set_vertex_halfedge	(	Halfedge *	,
		Halfedge *	,
		Tag_false
	)		const

inline

Definition at line 1069 of file Halfedge_data_structure_decorator.h.

1069 {}

void set_vertex_halfedge	(	Halfedge *	h,
		Halfedge *	g,
		Tag_true
	)		const

inline

Definition at line 1070 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge().

                                                                        {
         set_vertex_halfedge( h->vertex(), g);
     }

Here is the call graph for this function:

void set_vertex_in_vertex_loop	(	Halfedge *	,
		Vertex *	,
		Tag_false
	)

inline

Definition at line 345 of file Halfedge_data_structure_decorator.h.

Referenced by Halfedge_data_structure_decorator< _HDS >::erase_connected_component_vertex(), Halfedge_data_structure_decorator< _HDS >::set_vertex_in_vertex_loop(), and Halfedge_data_structure_decorator< _HDS >::split_vertex().

346 {}

Here is the caller graph for this function:

void set_vertex_in_vertex_loop	(	Halfedge *	h,
		Vertex *	v,
		Tag_true
	)

inline

Definition at line 347 of file Halfedge_data_structure_decorator.h.

References CGAL_assertion, CGAL_assertion_code, Halfedge::next(), and Halfedge::opposite().

                                               {
         CGAL_assertion_code( std::size_t termination_count = 0;)
         Halfedge* end = h;
         do {
             CGAL_assertion( ++termination_count != 0);
             h->set_vertex( v);
             h = h->next()->opposite();
         } while ( h != end);
     }

Here is the call graph for this function:

void set_vertex_in_vertex_loop	(	Halfedge *	h,
		Vertex *	v
	)

inline

Definition at line 358 of file Halfedge_data_structure_decorator.h.

References CGAL_precondition, and Halfedge_data_structure_decorator< _HDS >::set_vertex_in_vertex_loop().

                                                             {
         // Loops around the vertex incident to h and sets all vertex
         // pointers to v. Precondition: `h != NULL'.
         CGAL_precondition( h != 0);
         set_vertex_in_vertex_loop( h, v, Supports_halfedge_vertex());
     }

Here is the call graph for this function:

Halfedge* split_facet	(	HDS &	hds,
		Halfedge *	h,
		Halfedge *	g
	)

inline

Definition at line 387 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_facet(), Halfedge_data_structure_decorator< _HDS >::insert_tip(), Halfedge_data_structure_decorator< _HDS >::new_facet(), Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::set_facet(), Halfedge_data_structure_decorator< _HDS >::set_facet_halfedge(), and Halfedge_data_structure_decorator< _HDS >::set_facet_in_facet_loop().

                                                                {
         // split the facet incident to `h' and `g' into two facets with a
         // new diagonal between the two vertices denoted by `h' and `g'
         // respectively. The second (new) facet is a copy of the first
         // facet. It returns the new diagonal. The time is proportional to
         // the distance from `h' to `g' around the facet.
         Halfedge* hnew = hds.new_edge();
         Facet*    fnew = new_facet( hds, get_facet(h));
         insert_tip( hnew, g);
         insert_tip( hnew->opposite(), h);
         set_facet( hnew, get_facet(h));
         set_facet_in_facet_loop( hnew->opposite(), fnew);
         set_facet_halfedge( hnew);
         set_facet_halfedge( hnew->opposite());
         return hnew;
     }

Here is the call graph for this function:

Halfedge* split_loop	(	HDS &	hds,
		Halfedge *	h,
		Halfedge *	i,
		Halfedge *	j
	)

inline

Definition at line 483 of file Halfedge_data_structure_decorator.h.

                                                                           {
         // cuts `hds' into two parts along the cycle (h,i,j).
         // Three copies of the vertices, three copies of the halfedges,
         // and two new triangles will be created. h,i,j will be incident
         // to the first new triangle. The returnvalue will be an halfedge
         // iterator denoting the new halfedge of the second new triangle
         // which was h beforehand. Precondition: h,i,j are distinct,
         // consecutive vertices of `hds' and form a cycle: i.e.
         // `h->vertex() == i->opposite()->vertex()', ..., `j->vertex() ==
         // h->opposite()->vertex()'.
         CGAL_precondition( h != i);
         CGAL_precondition( h != j);
         CGAL_precondition( i != j);
         CGAL_precondition( get_vertex(h) == get_vertex(i->opposite()));
         CGAL_precondition( get_vertex(i) == get_vertex(j->opposite()));
         CGAL_precondition( get_vertex(j) == get_vertex(h->opposite()));
         // Create a copy of the triangle.
         Halfedge* hnew = hds.new_edge( h);
         Halfedge* inew = hds.new_edge( i);
         Halfedge* jnew = hds.new_edge( j);
         close_tip( hnew, new_vertex( hds, get_vertex( h)));
         close_tip( inew, new_vertex( hds, get_vertex( i)));
         close_tip( jnew, new_vertex( hds, get_vertex( j)));
         insert_tip( inew->opposite(), hnew);
         insert_tip( jnew->opposite(), inew);
         insert_tip( hnew->opposite(), jnew);
         // Make the new incidences with the old stucture.
         CGAL_assertion_code( std::size_t termination_count = 0;)
         if ( h->next() != i) {
             Halfedge* g = h->next();
             h->set_next( i);
             set_prev( i, h);
             hnew->set_next( g);
             set_prev( g, hnew);
             g = g->opposite();
             while ( g->next() != i) {
                 CGAL_assertion( ++termination_count != 0);
                 set_vertex( g, get_vertex( hnew));
                 g = g->next()->opposite();
             }
             set_vertex( g, get_vertex( hnew));
             g->set_next( inew);
             set_prev( inew, g);
         }
         if ( i->next() != j) {
             Halfedge* g = i->next();
             i->set_next( j);
             set_prev( j, i);
             inew->set_next( g);
             set_prev( g, inew);
             g = g->opposite();
             while ( g->next() != j) {
                 CGAL_assertion( ++termination_count != 0);
                 set_vertex( g, get_vertex( inew));
                 g = g->next()->opposite();
             }
             set_vertex( g, get_vertex( inew));
             g->set_next( jnew);
             set_prev( jnew, g);
         }
         if ( j->next() != h) {
             Halfedge* g = j->next();
             j->set_next( h);
             set_prev( h, j);
             jnew->set_next( g);
             set_prev( g, jnew);
             g = g->opposite();
             while ( g->next() != h) {
                 CGAL_assertion( ++termination_count != 0);
                 set_vertex( g, get_vertex( jnew));
                 g = g->next()->opposite();
             }
             set_vertex( g, get_vertex( jnew));
             g->set_next( hnew);
             set_prev( hnew, g);
         }
         // Fill the holes with two new facets.
         Facet* f = new_facet(hds);
         set_facet( h, f);
         set_facet( i, f);
         set_facet( j, f);
         set_facet_halfedge( h);
         f = new_facet(hds);
         set_facet( hnew->opposite(), f);
         set_facet( inew->opposite(), f);
         set_facet( jnew->opposite(), f);
         set_facet_halfedge( hnew->opposite());
         // Take care of maybe changed halfedge pointers.
         set_facet_halfedge( hnew);
         set_facet_halfedge( inew);
         set_facet_halfedge( jnew);
         set_vertex_halfedge( hnew);
         set_vertex_halfedge( inew);
         set_vertex_halfedge( jnew);
         return hnew->opposite();
     }

Here is the call graph for this function:

Halfedge* split_vertex	(	HDS &	hds,
		Halfedge *	h,
		Halfedge *	g
	)

inline

Definition at line 436 of file Halfedge_data_structure_decorator.h.

References Halfedge_data_structure_decorator< _HDS >::get_vertex(), Halfedge_data_structure_decorator< _HDS >::insert_halfedge(), Halfedge_data_structure_decorator< _HDS >::new_vertex(), Halfedge::opposite(), Halfedge_data_structure_decorator< _HDS >::set_vertex(), Halfedge_data_structure_decorator< _HDS >::set_vertex_halfedge(), and Halfedge_data_structure_decorator< _HDS >::set_vertex_in_vertex_loop().

                                                                 {
         // split the vertex incident to `h' and `g' into two vertices and
         // connects them with a new edge. The second (new) vertex is a
         // copy of the first vertex. It returns the new edge. The time is
         // proportional to the distance from `h' to `g' around the vertex.
         Halfedge* hnew = hds.new_edge();
         Vertex*   vnew = new_vertex( hds, get_vertex(h));
         insert_halfedge( hnew, g);
         insert_halfedge( hnew->opposite(), h);
         set_vertex( hnew, get_vertex(h));
         set_vertex_in_vertex_loop( hnew->opposite(), vnew);
         set_vertex_halfedge( hnew);
         set_vertex_halfedge( hnew->opposite());
         return hnew;
     }

Here is the call graph for this function:

The documentation for this class was generated from the following file:

Halfedge_data_structure_decorator.h

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Detailed Description

template<class _HDS> class Halfedge_data_structure_decorator< _HDS >

Member Typedef Documentation

Member Function Documentation

template<class _HDS>
class Halfedge_data_structure_decorator< _HDS >