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

cleanup

This commit is contained in:
Andreas Fabri 2007-10-06 19:37:51 +00:00
parent 9b8dbf7325
commit ecc8256bfa
13 changed files with 100 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
HalfedgeDS/doc_tex/HalfedgeDS/main.tex
View File

@ -46,9 +46,8 @@ Reduced variants of the halfedge data structure can omit some of these
information, for example the halfedge pointers in faces or the
storage of faces at all.}
In order to also support faces with
holes things can be slightly more complicated, that will be explained
in the next section.
In order to also support faces with holes things are slightly more
complicated, which will be explained in the next section.
% \begin{ccTexOnly}
% \vspace{-4mm}
@ -130,15 +129,15 @@ layer.
The items provide the space for the information that is
actually stored, i.e., with member variables and access member
functions in \ccc{Vertex}, \ccc{Halfedge}, \ccc{Halfedge_cycle} and
\ccc{Face} respectively. Halfedges are required to provide a reference to the
next halfedge and to the opposite halfedge. \ccc{Halfedge_cycles}
\ccc{Face}, respectively. Halfedges are required to provide a reference to the
next halfedge and to the opposite halfedge. Halfedge cycles
are required to provide a reference to one of the halfedges of the cycle
they represent.
Vertices, \ccc{Halfedge_cycles} and faces may be empty.
Vertices, halfedge cycles, and faces may be empty.
Vertices may provide a reference to the incident halfedge.
\ccc{Halfedge_cycles} may provide a reference to the face.
Faces may provide iterator ranges over the outer and inner \ccc{halfedge_cycles}, or,
alternatively, a reference to the incident halfedge if \ccc{halfedge_cycles} are not supported.
Halfedge cycles may provide a reference to the face.
Faces may provide iterator ranges over the outer and inner halfedge cycles, or,
alternatively, a reference to the incident halfedge if halfedge cycles are not supported.
}
The options mentioned are supported in the halfedge data structure and the
@ -148,9 +147,9 @@ extended with arbitrary attributes and member functions, which will be
promoted by inheritance to the actual classes used for the polyhedron.
Vertices, halfedges, {\XHDS halfedge\_cycles}, and faces are passed as local types of the
Vertices, halfedges, halfedge cycles, and faces are passed as local types of the
\ccc{Items} class to the halfedge data structure and polyhedron.
Implementations for vertices, halfedges, {\XHDS halfedge\_cycles}, and faces are provided that
Implementations for vertices, halfedges, halfedge cycles, and faces are provided that
fulfill the mandatory part of the requirements. They can be used as
base classes for extensions by the user. Richer implementations are
also provided to serve as defaults; for polyhedra they provide all
@ -226,7 +225,7 @@ type for vertices are defined. The trivial traits class provides the
type used for the point. The program creates a loop, consisting
of two halfedges, one vertex, and two faces, and checks its validity.
{\XHDS for backward compatibility with 3.3.1, the default items class
\ccc{HalfedgeDS_items_2} does not support \ccc{halfedge_cycles}.}
\ccc{HalfedgeDS_items_2} does not support halfedge cycles.}
\begin{ccTexOnly}
\vspace{-4mm}
@ -248,12 +247,12 @@ of two halfedges, one vertex, and two faces, and checks its validity.
% +-------------------------------------------------------------+
\subsection{The Default Halfedge Data Structure with halfedge\_cycles support}
\subsection{The Default Halfedge Data Structure with Halfedge Cycles Support}
{\XHDS
The following example program uses the default halfedge data structure
with \ccc{HalfedgeDS_items_with_halfedge_cycle_2}, enabling support for
\ccc{halfedge_cycles} and disabling direct mutual references between faces and halfedges
halfedge cycles and disabling direct mutual references between faces and halfedges
}
\ccIncludeExampleCode{HalfedgeDS/hds_prog_default_with_ccb.cpp}
@ -268,7 +267,7 @@ maintaining only halfedges with next and opposite pointers. No
vertices or faces are stored. The data structure represents an {\em
undirected graph}.
{\XHDS for backward compatibility,
\ccc{CGAL::HalfedgeDS_min_items} does not support \ccc{halfedge_cycles}.}
\ccc{CGAL::HalfedgeDS_min_items} does not support halfedge cycles.}
\ccIncludeExampleCode{HalfedgeDS/hds_prog_graph.cpp}

37
HalfedgeDS/doc_tex/HalfedgeDS_ref/Ccb_intro.tex
View File

@ -13,10 +13,10 @@ In some geometric structures, such as a \ccc{Polyhedron_3} or a \ccc{Straight_sk
faces are bounded by a single connected component. That is, just one cycle of halfedges bounds
any face. But in other structures, like an arrangement of curves in a surface, faces
might have holes or even multiple outer connected components of the boundary.
In these later cases, a face can be bounded by more than just one cycle of halfedges.
In the latter cases, a face can be bounded by more than just one cycle of halfedges.
Therefore, this design supports faces
whose boundaries are composed of multiple outer and inner halfedge cycles. Furthermore, faces can contain isolated vertices in its interior.
whose boundaries are composed of multiple outer and inner halfedge cycles. Furthermore, faces can contain isolated vertices in their interior.
\input{HalfedgeDS_ref/Ccb_or_dmr.tex}
@ -24,46 +24,43 @@ whose boundaries are composed of multiple outer and inner halfedge cycles. Furth
If multiple boundary components are not needed a type tag is used to allow a face to directly store
a reference to a halfedge (implicitly representing the cycle) and vice versa. In this case, \ccc{Face::halfedge()}, \ccc{Face::set_halfedge()}, \ccc{Halfedge::face()}
and \ccc{Halfedge::set_face()} are defined
and \ccc{Halfedge::set_face()} are defined.
\ccHeading{\ccc{Halfedge_cycle} Items:}
\ccHeading{Halfedge Cycle Items:}
Using this method a cycle of halfedges is collectively represented
by a fourth first-class \ccc{HDS} item named \ccc{halfedge_cycle}
by a fourth first-class \ccc{HDS} item named \ccc{Halfedge_cycle}.
A face stores sequences of outer and inner \ccc{halfedge_cycle} handles, while each
\ccc{halfedge_cycle} in turn stores a reference to a halfedge\footnote{In other
When using halfedge cycles, incident faces and halfedges are not directly cross referenced.
Instead, a face stores sequences of references to outer and inner halfedge cycles, while each
halfedge cycle in turn stores a reference to a halfedge\footnote{In other
hole-supporting HDS designs, faces stores a sequence of halfedges (each for a different cycle).
In our design a cycle is given by a \ccc{halfedge_cycle} instead of a \ccc{halfedge} to allow
the centralization of cycle-related information}.
A face also stores another sequence of \ccc{halfedge_cycle} handles for isolated vertices where
A face also stores another sequence of references to halfedge_cycles for isolated vertices, where
each such vertex is represented by a cycle composed of a single-halfedge single-vertex self-loop.
A halfedge in the cycle stores the handle to the halfedge cycle it belongs to.
When using \ccc{halfedge_cycles}, incident faces and halfedges are not directly cross referenced. Instead,
they are indirectly related via a common \ccc{halfedge_cycle} object: faces store
\ccc{halfedge_cycle} handles and each halfedge in the cycle stores the handle to the
\ccc{halfedge_cycle} it belongs to.
\ccc{Face::halfedge()} {\em is not} defined if \ccc{halfedge_cycles} are used because a face
can have many cycles, not just one; or it could have only inner cycles (holes).
\ccc{Face::halfedge()} is not defined if halfedge cycles are used because a face
can have many cycles, not just one; or oven no outer boudary but only inner cycles (holes).
\ccc{Halfedge::face()} on the other hand is well defined as a shortcut for \ccc{Halfedge::halfedge_cycle()->face()}
since every halfedge belongs to a \ccc{halfedge_cycle}.
since every halfedge belongs to a halfedge_cycle.
A \ccc{halfedge_cycle} is a first-class \ccc{HDS} item, just like vertices, halfedges and faces.
However, a \ccc{halfedge_cycle} does not contribute {\em by itself} to the incidence information
THe type \ccc{Halfedge_cycle} is a first-class \ccc{HDS} item, just like vertices, halfedges and faces.
However, the halfedge cycles do not contribute by themself to the incidence information
maintained by the \ccc{HDS}. That is, the incidence is betwen vertices, edges and faces,
which are all well defined mathematical concepts belonging to the field of algebraic topology.
This design does not introduce a new topological concept but a new
auxiliary object in a similar way halfedges are auxiliary objects that
relate to the topological concept of {\em edge} only when considered in pairs.
A \ccc{halfedge_cycle} allows upper level structures to centralize boundary-related information
A halfedge cycle allows upper level structures to centralize boundary-related information
(combinatorial or geometric) in a single object. This is the reason why
connected components of the boundary are represented by this first-class \ccc{HDS} item
and not just by a halfedge implicitly representing the cycle (as in other designs).
For instance, a derived \ccc{halfedge_cycle} can store the iterator that identifies the position of
For instance, a model of the concept \ccc{HalfedgeDSHalfedgeCycle} may store the iterator that identifies the position of
cycle in the face for fast hole migration across different faces, or cache curve-level geometric
information such as orientation even if not supported by the curve type itself.
}

14
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS.tex
View File

@ -141,17 +141,6 @@ allocators internally. A default argument is mandatory for
from the \ccc{<CGAL/memory.h>} header file can be used as default
allocator.
% +-----------------------------------+
\ccHeading{Release Notes}
\input{HalfedgeDS_ref/Extension_intro.tex}
Beginning with \cgal\ R2.3, this package has a new design. The old
design is still available for backwards compatibility and to support
older compiler, such as MSVC++6.0. However its use is deprecated and
the manual pages are not converted into this new manual
format. Instead, see its old documentation in the manual of
deprecated packages. The two designs are not interchangeable.
% +-----------------------------------+
@ -214,7 +203,7 @@ value. It will be used in analogy to \ccc{NULL} for pointers.
The following types are equal to either \ccStyle{CGAL::Tag_true} or
\ccStyle{CGAL::Tag_false}, depending on whether the named feature is
supported or not.
\newpage
\ccNestedType{Supports_vertex_halfedge}{\ccc{Vertex::halfedge()}.}
\ccGlue
@ -325,7 +314,6 @@ arises.
\end{ccAdvanced}
\newpage
% +-----------------------------------+
\ccCreation
\ccThree{HalfedgeDS<Traits,Items,Alloc>& }{functionfoo}{}

4
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSCcb.tex
View File

@ -48,10 +48,6 @@ halfedge data structure they must be derived from a base class \ccc{Base}
where the modifying member functions are still public. (The protection
can be bypassed by the user, but not by accident.)
\ccHeading{Release Notes}
This has been introduced in \cgal\ version 3.4.
\ccTypes
\ccThree{Halfedge_const_handle}{v.set_halfedge( Halfedge_handle h);}{}

24
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSFace.tex
View File

@ -24,10 +24,12 @@ type in the \ccc{HalfedgeDS} concept. It is also required in
the \ccc{Face_wrapper<Refs,Traits>} member class template of an
items class, see the \ccc{HalfedgeDSItems} concept.
See page~\ref{pageHalfedgeDSHalfedgeCycleIntro} for an introduction to Faces with Several Boundaries.
See page~\ref{pageHalfedgeDSHalfedgeCycleIntro} for an introduction to faces with several boundaries.
{\XHDS
If \ccc{halfedge_cycles} are used, a face optionally stores begin and end iterators for the outer and inner \ccc{halfedge_cycle} sequences. It also optionally stores iterators for the sequence of \ccc{halfedge_cycles} corresponding to isolated vertices.
If halfedge cycles are used, a face optionally stores begin and end iterators for the sequences
of outer and inner halfedge cycles. It also optionally stores iterators for the sequence of halfedge cycles
corresponding to isolated vertices.
If, alternatively, direct mutual reference is used, a face optionally stores a reference
to an incident halfedge that points to the face.
A type tag indicates whether the related member functions are supported.
@ -35,9 +37,8 @@ A type tag indicates whether the related member functions are supported.
{\XHDS
The choice between using \ccc{halfedge_cycles} or direct mutual reference
(to define the incidence relation between faces and halfedges) is selected
via a combination of type tags:
The choice between using halfedge cycles or direct mutual reference
is made via a combination of type tags:
For direct mutual reference use
@ -45,7 +46,7 @@ For direct mutual reference use
and
\ccc{Supports_face_halfedge_cycle} $\equiv$ \ccc{CGAL::Tag_false}
For halfedge\_cycle items use:
For halfedge cycle items use:
\ccc{Supports_face_halfedge} $\equiv$ \ccc{CGAL::Tag_false}
and
@ -55,13 +56,13 @@ and
\begin{ccAdvanced}
{\XHDS
The storage for \ccc{halfedge_cycle} items is controlled by the \ccc{HDS} itself. Therefore,
The storage for halfedge cycle items is controlled by the \ccc{HDS} itself. Therefore,
there is a \ccc{Halfedge_cycle_iterator} type local to \ccc{HalfedgeDS} corresponding to a
container whose elements are models of \ccc{HalfedgeDSHalfedgeCycle}.
Faces maintain their own local sequences of \ccc{halfedge_cycles}. These sequences are
Faces maintain their own local sequences of halfedge cycles. These sequences are
containers of \ccc{Halfedge_cycle_handle} elements, not of \ccc{Halfedge_cycle} elements (like the
container in the HDS). Thus, a Face defines a local \ccc{Halfedge_cycle_handle_iterator} type.
container in the HDS). Thus, a face defines a local \ccc{Halfedge_cycle_handle_iterator} type.
While a \ccc{Halfedge_cycle_iterator} is implicitly convertible to a \ccc{Halfedge_cycle_handle},
a \ccc{Halfedge_cycle_handle_iterator} is {\em dereferenceable} as a \ccc{Halfedge_cycle_handle}
@ -72,7 +73,7 @@ a \ccc{Halfedge_cycle_handle_iterator} is {\em dereferenceable} as a \ccc{Halfed
\begin{ccAdvanced}
{\XHDS
As faces can have more than one outer boundary, an upper level data structure could use a single
face to represent disjoint regions each bounded by a distinct outer \ccc{halfedge_cycle}. However,
face to represent disjoint regions each bounded by a distinct outer halfedge cycle. However,
it is highly recommended to restrict faces to correspond to singly connected regions, and
to use multiple outer cycles to represent disjoint boundary components around the same
connected region. For example, the surface of a cross section of a cylinder is a single
@ -96,9 +97,6 @@ halfedge data structure they must be derived from a base class \ccc{Base}
where the modifying member functions are still public. (The protection
can be bypassed by the user, but not by accident.)
\ccHeading{Release Notes}
\input{HalfedgeDS_ref/Extension_intro.tex}
\ccTypes

6
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSHalfedge.tex
View File

@ -33,8 +33,8 @@ along the open region.
A halfedge optionally stores a reference to the
previous halfedge along the face, a reference to an incident vertex,
{\XHDS a reference to the \ccc{halfedge_cycle} containing it},
and a reference to the incident face,
{\XHDS a reference to the halfedge cycle containing it},
and a reference to the incident face.
Type tags indicate whether the related member functions are supported.
{\XHDS
@ -49,7 +49,7 @@ For direct mutual reference use
and
\ccc{Supports_halfedge_halfedge_cycle} $\equiv$ \ccc{CGAL::Tag_false}
For \ccc{halfedge_cycle} items use:
For halfedge cycle items use:
\ccc{Supports_halfedge_face} $\equiv$ \ccc{CGAL::Tag_false}
and

8
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_const_decorator.tex
View File

@ -65,14 +65,14 @@ but a useful set of tests is defined with the following levels:
\begin{description}
\item[Level 0]
The number of halfedges is even. All pointers except
the vertex pointer and the face pointer for border halfedges and halfedge\_cycles
the vertex pointer and the face pointer for border halfedges and halfedge cycles
are unequal to their respective default construction value. For all
halfedges $h$: The opposite halfedge is different from $h$ and the
opposite of the opposite is equal to $h$. The next of the previous
halfedge is equal to $h$. For all vertices $v$: the incident vertex
of the incident halfedge of $v$ is equal to $v$. The halfedges
around $v$ starting with the incident halfedge of $v$ form a cycle.
For all \ccc{halfedge_cycles} $c$: The halfedges starting with the halfedge
For all halfedge cycles $c$: The halfedges starting with the halfedge
referenced by $c$ from a cycle and are all incident to the same face
$f$ referenced by $c$ (or are all border halfedges).
For all faces $f$: the incident face of the incident halfedge of $f$
@ -86,7 +86,7 @@ but a useful set of tests is defined with the following levels:
incident vertex of $h$ exists and is equal to the incident vertex of
the opposite of the next halfedge. The incident face (or hole) of
$h$ is equal to the incident face (or hole) of the next halfedge.
The \ccc{halfedge_cycle} of $h$ is equal to the \ccc{halfedge_cycle}
The halfedge cycle of $h$ is equal to the halfedge cycle
of the next halfedge.
\item[Level 2]
All tests of level 1. The sum of all halfedges that can
@ -98,7 +98,7 @@ but a useful set of tests is defined with the following levels:
be reached through the faces must be equal to the number of all
halfedges, i.e., all halfedges surrounding a face must form a single
cycle (no holes in faces). Likewise for the sum of all halfedges that
can be reached through the halfedge\_cycles.
can be reached through the halfedge cycles.
\item[Level 4]
All tests of level 3 and \ccc{normalized_border_is_valid}.
\end{description}

66
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_decorator.tex
View File

@ -23,7 +23,7 @@ The classes \ccc{CGAL::HalfedgeDS_items_decorator<HDS>},
\ccc{CGAL::HalfedgeDS_const_decorator<HDS>} provide additional functions
to examine and to modify a halfedge data structure \ccc{HDS}. The class
\ccc{CGAL::HalfedgeDS_items_decorator<HDS>} provides additional functions
for vertices, halfedges, \ccc{\XHDS halfedge_cycles}, and faces
for vertices, halfedges, \ccc{\XHDS halfedge cycles}, and faces
of a halfedge data structure without knowing the containing
halfedge data structure. The class
\ccc{CGAL::HalfedgeDS_decorator<HDS>} stores a reference to the halfedge
@ -69,29 +69,29 @@ all halfedge data structures and will not appear here again.
Returns a handle of the new face, or \ccc{Face_handle()} otherwise.}
\ccGlue
\ccMethod{\XHDS Halfedge_cycle_handle halfedge_cycles_push_back( const Halfedge_cycle& c);}{\XHDS
appends a copy of $c$ to \ccc{hds} if \ccc{halfedge_cycles} are supported.
Returns a handle of the new \ccc{halfedge_cycle}, or \ccc{Halfedge_cycle_handle()} otherwise.}
appends a copy of $c$ to \ccc{hds} if halfedge cycles are supported.
Returns a handle of the new halfedge cycle, or \ccc{Halfedge_cycle_handle()} otherwise.}
% -----------------------------------------
\ccHeading{Creation of New Composed Items}
\ccMethod{Halfedge_handle create_loop();}{
returns handle of a halfedge from a newly created loop in \ccc{hds}
returns the handle of a halfedge from a newly created loop in \ccc{hds}
consisting of a single closed edge, one vertex and two faces
{\XHDS each with one outer \ccc{halfedge_cycle}}
{\XHDS each with one outer halfedge cycle}
(if supported respectively).}
\ccGlue
\ccMethod{Halfedge_handle create_segment();}{
returns a halfedge from a newly created segment in \ccc{hds}
consisting of a single open edge, two vertices, one face
{\XHDS and one outer \ccc{halfedge_cycle}}
{\XHDS and one outer halfedge cycle}
(if supported respectively).}
\ccGlue
\ccMethod{\XHDS Halfedge_handle create_isolated_vertex();}{\XHDS
returns handle of a halfedge from a newly created loop in \ccc{hds}
consisting of a single closed edge belonging to one \ccc{halfedge_cycle} (if supported)
consisting of a single closed edge belonging to one halfedge cycle (if supported)
and one single vertex.
Unlike \ccc{create_loop} this method doesn't create two faces.
Unlike \ccc{create_loop} this method does not create two faces.
}
% -----------------------------------------
@ -103,25 +103,25 @@ The following member functions do {\em not\/} update affected
incidence relations except if mentioned otherwise.
\ccMethod{void vertices_pop_front();}{
removes the first vertex if vertices are supported.
removes the first vertex, if vertices are supported.
\ccCommentHeading{Requirement} \ccc{Supports_removal} $\equiv$
\ccc{CGAL::Tag_true}.}
\ccGlue
\ccMethod{void vertices_pop_back();}{
removes the last vertex if vertices are supported.}
removes the last vertex, if vertices are supported.}
\ccGlue
\ccMethod{void vertices_erase( Vertex_handle v);}{
removes the vertex $v$ if vertices are supported.
removes the vertex $v$, if vertices are supported.
\ccCommentHeading{Requirement} \ccc{Supports_removal} $\equiv$
\ccc{CGAL::Tag_true}.}
\ccGlue
\ccMethod{void vertices_erase( Vertex_handle first, Vertex_handle last);}{
removes the range $[\ccc{first},\ccc{last})$ if vertices
removes the range $[\ccc{first},\ccc{last})$, if vertices
are supported. \ccCommentHeading{Requirement} \ccc{Supports_removal}
$\equiv$ \ccc{CGAL::Tag_true}.}
\ccMethod{void faces_pop_front();}{
removes the first face if faces are supported.
removes the first face, if faces are supported.
\ccCommentHeading{Requirement} \ccc{Supports_removal} $\equiv$
\ccc{CGAL::Tag_true}.}
\ccGlue
@ -129,37 +129,37 @@ incidence relations except if mentioned otherwise.
removes the last face if faces are supported.}
\ccGlue
\ccMethod{void faces_erase( Face_handle f);}{
removes the face $f$ if faces are supported.
removes the face $f$, if faces are supported.
\ccCommentHeading{Requirement} \ccc{Supports_removal} $\equiv$
\ccc{CGAL::Tag_true}.}
\ccGlue
\ccMethod{void faces_erase( Face_handle first, Face_handle last);}{
removes the range $[\ccc{first},\ccc{last})$ if faces are
removes the range $[\ccc{first},\ccc{last})$, if faces are
supported. \ccCommentHeading{Requirement} \ccc{Supports_removal}
$\equiv$ \ccc{CGAL::Tag_true}.}
\ccMethod{\XHDS void halfedge_cycles_pop_front();}{\XHDS
removes the first \ccc{halfedge_cycle} if \ccc{halfedge_cycles} are supported.
removes the first halfedge cycle, if halfedge cycles are supported.
\ccCommentHeading{Requirement} \ccc{Supports_removal} $\equiv$
\ccc{CGAL::Tag_true}.}
\ccGlue
\ccMethod{\XHDS void halfedge_cycles_pop_back();}{\XHDS
removes the last \ccc{halfedge_cycle} if faces are supported.}
removes the last halfedge cycle, if faces are supported.}
\ccGlue
\ccMethod{\XHDS void halfedge_cycles_erase( Halfedge_cycle_handle b);}{\XHDS
removes the \ccc{halfedge_cycle} $b$ if \ccc{halfedge_cycles} are supported.
removes the halfedge cycle $b$, if \ccc{halfedge_cycles} are supported.
\ccCommentHeading{Requirement} \ccc{Supports_removal} $\equiv$
\ccc{CGAL::Tag_true}.}
\ccGlue
\ccMethod{\XHDS void halfedge_cycles_erase( Halfedge_cycle_handle first, Halfedge_cycle_handle last);}{\XHDS
removes the range $[\ccc{first},\ccc{last})$ if \ccc{halfedge_cycles} are
removes the range $[\ccc{first},\ccc{last})$, if halfedge cycles are
supported. \ccCommentHeading{Requirement} \ccc{Supports_removal}
$\equiv$ \ccc{CGAL::Tag_true}.}
\ccMethod{void erase_face( Halfedge_handle h);} {removes the
face incident to \ccc{h} from \ccc{hds} and changes all halfedges
incident to the face into border edges or removes them from the
\ccc{hds}, {\XHDS along with the \ccc{halfedge_cycles} containing them},
\ccc{hds}, {\XHDS along with the halfedge cycles containing them},
if they were already border edges.
If this creates isolated vertices they get removed as well. See
\ccc{make_hole(h)} for a more specialized variant.
@ -168,7 +168,7 @@ incidence relations except if mentioned otherwise.
\ccc{Supports_removal} $\equiv$ \ccc{CGAL::Tag_true}.}
\ccMethod{void erase_connected_component( Halfedge_handle h);}
{removes the vertices, halfedges, halfedge\_cycles {\XHDS and faces}
{removes the vertices, halfedges, halfedge cycles {\XHDS and faces}
that belong to the connected component of $h$.
\ccPrecond For all halfedges $g$ in the
connected component \ccc{g.next() != Halfedge_handle()}.
@ -190,7 +190,7 @@ incidence relations except if mentioned otherwise.
}
\ccMethod{\XHDS Halfedge_cycle_handle host_halfedge( Halfedge_handle h);}
{\XHDS Associates $h$ with $c$, a new \ccc{halfedge_cycle} created from \ccc{hds}.
{\XHDS Associates $h$ with $c$, a new halfedge cycle created from \ccc{hds}.
Returns \ccc{c}.
\ccPrecond \ccc{h != Halfedge_handle()} and \ccc{h->halfedge_cycle() == Halfedge_cycle_handle()}.}
@ -274,17 +274,17 @@ the halfedge \ccc{h->next} with a new face in-between.
\ccMethod{Halfedge_handle split_face( Halfedge_handle h, Halfedge_handle g);}
{splits the face incident to \ccc{h} and \ccc{g} into two faces
with a new diagonal between the two vertices denoted by \ccc{h} and
\ccc{g} respectively. \ccc{h} and \ccc{g} must belong to the same \ccc{halfedge_cycle}.
The second (new) face {\XHDS and \ccc{halfedge_cycle}}
obtained from \ccc{hds} are a copy of the first face {\XHDS and \ccc{halfedge_cycle}}.
\ccc{g} respectively. \ccc{h} and \ccc{g} must belong to the same halfedge cycle.
The second (new) face {\XHDS and halfedge cycle}
obtained from \ccc{hds} are a copy of the first face {\XHDS and halfedge cycle}.
Returns \ccc{h->next()} after the operation, i.e., the new diagonal.
The new face is to the right of the new diagonal
{\XHDS (thus the new \ccc{halfedge_cycle} contains \ccc{g})}
, the old face is to the left
{\XHDS (and the old \ccc{halfedge_cycle} contains \ccc{h})}.
{\XHDS (thus the new halfedge cycle contains \ccc{g})},
the old face is to the left
{\XHDS (and the old halfedge cycle contains \ccc{h})}.
The time is proportional
to the distance from \ccc{h} to \ccc{g} around the face.
{\XHDS If \ccc{h->face()} contains any other \ccc{halfedge_cycles}
{\XHDS If \ccc{h->face()} contains any other halfedge cycles
besides \ccc{h->halfedge_cycle()},
they are kept in \ccc{h->face()}. It is the responsibility of the upper level
data struct to migrate other cycles to the second face if applicable.}
@ -292,7 +292,7 @@ the halfedge \ccc{h->next} with a new face in-between.
\ccMethod{Halfedge_handle join_face( Halfedge_handle h);}
{joins the two faces incident to $h$. The face incident to
\ccc{h->opposite()} {\XHDS and the \ccc{halfedge_cycle} it belongs to}
\ccc{h->opposite()} {\XHDS and the halfedge cycle it belongs to}
get removed from \ccc{hds}.
Both faces might be holes. Returns the predecessor of $h$ around the face. The invariant
\ccc{join_face( split_face( h, g))} returns $h$ and keeps
@ -349,12 +349,12 @@ the halfedge \ccc{h->next} with a new face in-between.
to \ccc{h->face()} splitting \ccc{h->face()}
{\XHDS and \ccc{h->halfedge_cycle()}} into triangles.
\ccc{h} remains incident to the original face {\XHDS
and belonging to the original \ccc{halfedge_cycle}}, all other triangles
are copies of this face {\XHDS and \ccc{halfedge_cycle}}.
and belonging to the original halfedge cycle}, all other triangles
are copies of this face {\XHDS and halfedge cycle}.
Returns the halfedge \ccc{h->next()}
after the operation, i.e., a halfedge pointing to the new vertex.
The time is proportional to the size of the face.
{\XHDS If \ccc{h->face()} contains any other \ccc{halfedge_cycles}
{\XHDS If \ccc{h->face()} contains any other halfedge cycles
besides \ccc{h->halfedge_cycle()},
they are kept in \ccc{h->face()}. It is the responsibility of the upper level
data struct to migrate other cycles to the other faces if applicable.}

10
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_face_base.tex
View File

@ -27,7 +27,7 @@ defaults that allow to select various flavors of faces.
\begin{tabbing}
\mbox{}~~~~~~ \= \ccc{template <} \=\ccc{class Refs,}\\
\> \>\ccc{class Tag_halfedge } \=\ccc{= CGAL::Tag_true,}\\
\> \>\ccc{class Tag_halfedge } \mbox{}~~~ \=\ccc{= CGAL::Tag_true,}\\
\> \>\ccc{class Tag_plane } \>\ccc{= CGAL::Tag_false,}\\
\> \>\ccc{class Tag_halfedge_cycle} \>\ccc{= CGAL::Tag_true}\\
\> \ccc{class HalfedgeDS_face_base;}
@ -37,7 +37,7 @@ If \ccc{Tag_halfedge} $\equiv$ \ccc{CGAL::Tag_true} a reference to the incident
If \ccc{Tag_plane} $\neq$ \ccc{CGAL::Tag_false} a plane object is supported (and the type \ccc{Tag_plane} corresponds to the type of the plane object).
If \ccc{Tag_halfedge_cycle} $\equiv$ \ccc{CGAL::Tag_true} \ccc{halfedge_cycle} sequences are supported.
If \ccc{Tag_halfedge_cycle} $\equiv$ \ccc{CGAL::Tag_true} halfedge cycles are supported.
Faces may be bounded by one or multiple halfedge cycles and a face object can optionally store the bounding cycle in one of two mutually exclusive ways:
@ -47,14 +47,12 @@ with \ccc{Tag_halfedge} $\equiv$ \ccc{CGAL::Tag_true}
or
Storing iterator pairs defining the sequences of outer and inner \ccc{halfedge_cycles} that bound the face.
Storing iterator pairs defining the sequences of outer and inner halfedge cycles that bound the face.
With \ccc{Tag_halfedge_cycle} $\equiv$ \ccc{CGAL::Tag_true}
\ccHeading{Release Notes}
Since multiple halfedge cycles were introduced in \cgal\ version 3.4, to keep backward compatibility,
the choice between storing just one halfedge or \ccc{halfedge_cycle} sequences is selected by the combination
The choice between storing just one halfedge or \ccc{halfedge_cycle} sequences is made by the combination
of the two type tags \ccc{Tag_halfedge} and \ccc{Tag_halfedge_cycle}. These are mutually
exclusive and only one can be \ccc{CGAL::Tag_true}.

9
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_halfedge_base.tex
View File

@ -40,22 +40,19 @@ supported.
If \ccc{Tag_face} $\equiv$ \ccc{CGAL::Tag_true} an incident face is
supported.
{\XHDS If \ccc{Tag_halfedge_cycle} $\equiv$ \ccc{CGAL::Tag_true} a host \ccc{halfedge_cycle} is
{\XHDS If \ccc{Tag_halfedge_cycle} $\equiv$ \ccc{CGAL::Tag_true} a host halfedge cycle is
supported.}
{\XHDS
The incidence relation between a halfedge and a face can be stored in a halfedge in
one of two mutually exclusive ways: directly storing the incident face or
storing the \ccc{halfedge_cycle} common to the halfedge and face.
storing the halfedge cycle common to the halfedge and face.
}
In all cases, a reference to the next halfedge and to the opposite
halfedge is supported.
\ccHeading{Release Notes}
Multiple halfedge cycles were introduced in \cgal\ version 3.4.
To keep backward compatibility, the choice between those methods is selected by the combination
The choice between those methods is selected by the combination
of the two type tags \ccc{Tag_face} and \ccc{Tag_halfedge_cycle}.
These are mutually exclusive and only one can be \ccc{CGAL::Tag_true}.

7
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_2.tex
View File

@ -22,8 +22,7 @@
The class \ccRefName\ is a model of the \ccc{HalfedgeDSItems} concept.
It uses the default types for vertices, halfedges, and faces that
declare all incidences supported by a \ccc{HalfedgeDS}.
{\XHDS \ccc{halfedge_cycles} are not supported
(thus faces and halfedges reference each other directly)}.
{\XHDS Halfedge cycles are not supported.
The vertex also contains a point of type \ccc{Traits::Point_2},
where \ccc{Traits} is the template argument of the corresponding \ccc{HalfedgeDS}.
@ -42,7 +41,7 @@ where \ccc{Traits} is the template argument of the corresponding \ccc{HalfedgeDS
\ccRefConceptPage{PolyhedronItems_3}\\
\ccRefIdfierPage{CGAL::HalfedgeDS_vertex_base<Refs>}\\
\ccRefIdfierPage{CGAL::HalfedgeDS_halfedge_base<Refs>}\\
\ccRefIdfierPage{CGAL::HalfedgeDS_face_base<Refs>}
\ccRefIdfierPage{CGAL::HalfedgeDS_face_base<Refs>}\\
\ccRefIdfierPage{CGAL::HalfedgeDS_halfedge_cycle_base<Refs>}
\ccExample
@ -67,7 +66,7 @@ struct HalfedgeDS_items_2 {
typedef CGAL::HalfedgeDS_face_base< Refs> Face;
};
// Halfedge_cycles are not supported by default, hence a dumy type is used.
// Halfedge_cycles are not supported by default, hence a dummy type is used.
template < class Refs, class Traits>
struct Halfedge_cycle_wrapper {
typedef int Halfedge_cycle;

10
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_decorator.tex
View File

@ -23,7 +23,7 @@ The classes \ccc{CGAL::HalfedgeDS_items_decorator<HDS>},
\ccc{CGAL::HalfedgeDS_const_decorator<HDS>} provide additional functions
to examine and to modify a halfedge data structure \ccc{HDS}. The class
\ccc{CGAL::HalfedgeDS_items_decorator<HDS>} provides additional functions
for vertices, halfedges, {\XHDS \ccc{halfedge_cycles}}, and faces
for vertices, halfedges, {\XHDS halfedge cycles}, and faces
of a halfedge data structure
without knowing the containing halfedge data structure. The class
\ccc{CGAL::HalfedgeDS_decorator<HDS>} stores a reference to the halfedge
@ -57,7 +57,7 @@ all halfedge data structures and will not appear here again.
\ccGlue
\ccNestedType{Face}{face type of \ccc{HalfedgeDS}.}
\ccGlue
\ccNestedType{\XHDS Halfedge_cycle}{\XHDS \ccc{halfedge_cycle} type of \ccc{HalfedgeDS}.}
\ccNestedType{\XHDS Halfedge_cycle}{\XHDS halfedge cycle type of \ccc{HalfedgeDS}.}
\ccNestedType{Vertex_handle}{}
\ccGlue
@ -140,11 +140,11 @@ available as well.
\ccc{Face_handle()} otherwise.}
\ccGlue
\ccMethod{\XHDS Halfedge_cycle_handle get_halfedge_cycle(Halfedge_handle h);}
{\XHDS returns the \ccc{halfedge_cycle} of $h$ if supported,
{\XHDS returns the halfedge cycle of $h$ if supported,
\ccc{Halfedge_cycle_handle()} otherwise.}
\ccGlue
\ccMethod{\XHDS Halfedge_cycle_handle get_halfedge_cycle(Face_handle f);}
{\XHDS returns the \ccc{halfedge_cycle} of $f$ if supported,
{\XHDS returns the halfedge cycle of $f$ if supported,
\ccc{Halfedge_cycle_handle()} otherwise.}
\ccGlue
\ccMethod{Halfedge_handle get_face_halfedge( Face_handle f);}
@ -232,7 +232,7 @@ Corresponding member functions for \ccc{const_handle}'s are provided as well.
{sets the incident halfedge of the face incident to $h$ to $h$.}
\ccGlue
\ccMethod{\XHDS void set_halfedge_cycle( Halfedge_handle h, Halfedge_cycle_handle c) const;}
{\XHDS sets the \ccc{halfedge_cycle} of $h$ to $c$.}
{\XHDS sets the halfedge cycle of $h$ to $c$.}
\ccGlue
\ccMethod{\XHDS void insert_outer_halfedge_cycle_to_face( Face_handle f, Halfedge_cycle_handle c, Halfedge_cycle_handle_iterator pos) const;}
{\XHDS inserts $c$ to sequence of outer cycles of $f$ before $pos$.}

4
HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_with_ccb_2.tex
View File

@ -20,7 +20,7 @@
\ccDefinition
The class \ccRefName\ is a model of the \ccc{HalfedgeDSItems} concept.
It uses the default types for vertices, halfedges, \ccc{halfedge_cycles}, and faces
It uses the default types for vertices, halfedges, halfedge cycles, and faces
that declare all incidences supported by a \ccc{HalfedgeDS}. The vertex
also contains a point of type \ccc{Traits::Point_2}, where \ccc{Traits}
is the template argument of the corresponding \ccc{HalfedgeDS}.
@ -40,7 +40,7 @@ is the template argument of the corresponding \ccc{HalfedgeDS}.
\ccRefConceptPage{PolyhedronItems_3}\\
\ccRefIdfierPage{CGAL::HalfedgeDS_vertex_base<Refs>}\\
\ccRefIdfierPage{CGAL::HalfedgeDS_halfedge_base<Refs>}\\
\ccRefIdfierPage{CGAL::HalfedgeDS_face_base<Refs>}
\ccRefIdfierPage{CGAL::HalfedgeDS_face_base<Refs>}\\
\ccRefIdfierPage{CGAL::HalfedgeDS_halfedge_cycle_base<Refs>}
\ccExample