diff --git a/HalfedgeDS/doc_tex/HalfedgeDS/main.tex b/HalfedgeDS/doc_tex/HalfedgeDS/main.tex index dff8a4f427d..1f388e82e30 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS/main.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS/main.tex @@ -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} diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/Ccb_intro.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/Ccb_intro.tex index 91c7e3f9773..3721e056c2d 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/Ccb_intro.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/Ccb_intro.tex @@ -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. } diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS.tex index 06be9547c68..fd4f32e8f55 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS.tex @@ -141,17 +141,6 @@ allocators internally. A default argument is mandatory for from the \ccc{} 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& }{functionfoo}{} diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSCcb.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSCcb.tex index d4797b91eb2..4db936c77f9 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSCcb.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSCcb.tex @@ -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);}{} diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSFace.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSFace.tex index feabcabcb7c..8a95d86cc29 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSFace.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSFace.tex @@ -24,10 +24,12 @@ type in the \ccc{HalfedgeDS} concept. It is also required in the \ccc{Face_wrapper} 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 diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSHalfedge.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSHalfedge.tex index 741fdd71bff..7f381dbf968 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSHalfedge.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDSHalfedge.tex @@ -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 diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_const_decorator.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_const_decorator.tex index 141674a012c..d54c449a2a7 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_const_decorator.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_const_decorator.tex @@ -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} diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_decorator.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_decorator.tex index cdf769e767f..13d1f067d20 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_decorator.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_decorator.tex @@ -23,7 +23,7 @@ The classes \ccc{CGAL::HalfedgeDS_items_decorator}, \ccc{CGAL::HalfedgeDS_const_decorator} provide additional functions to examine and to modify a halfedge data structure \ccc{HDS}. The class \ccc{CGAL::HalfedgeDS_items_decorator} 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} 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.} diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_face_base.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_face_base.tex index 4645f684643..85e670a8b82 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_face_base.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_face_base.tex @@ -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}. diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_halfedge_base.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_halfedge_base.tex index 097208297c2..5c6bd586f92 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_halfedge_base.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_halfedge_base.tex @@ -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}. diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_2.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_2.tex index 32b7385cdc2..91193ce8668 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_2.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_2.tex @@ -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}\\ \ccRefIdfierPage{CGAL::HalfedgeDS_halfedge_base}\\ -\ccRefIdfierPage{CGAL::HalfedgeDS_face_base} +\ccRefIdfierPage{CGAL::HalfedgeDS_face_base}\\ \ccRefIdfierPage{CGAL::HalfedgeDS_halfedge_cycle_base} \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; diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_decorator.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_decorator.tex index d692a10be42..58bd8df80fd 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_decorator.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_decorator.tex @@ -23,7 +23,7 @@ The classes \ccc{CGAL::HalfedgeDS_items_decorator}, \ccc{CGAL::HalfedgeDS_const_decorator} provide additional functions to examine and to modify a halfedge data structure \ccc{HDS}. The class \ccc{CGAL::HalfedgeDS_items_decorator} 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} 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$.} diff --git a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_with_ccb_2.tex b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_with_ccb_2.tex index c94ba91ebbe..c8e2d3998e2 100644 --- a/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_with_ccb_2.tex +++ b/HalfedgeDS/doc_tex/HalfedgeDS_ref/HalfedgeDS_items_with_ccb_2.tex @@ -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}\\ \ccRefIdfierPage{CGAL::HalfedgeDS_halfedge_base}\\ -\ccRefIdfierPage{CGAL::HalfedgeDS_face_base} +\ccRefIdfierPage{CGAL::HalfedgeDS_face_base}\\ \ccRefIdfierPage{CGAL::HalfedgeDS_halfedge_cycle_base} \ccExample