From 77b21c65ef5aa788386de4f003d7de655c3ad5b6 Mon Sep 17 00:00:00 2001 From: Tran Kai Frank Da Date: Wed, 27 Oct 1999 13:50:17 +0000 Subject: [PATCH] minor corrections. --- .../doc_tex/Alpha_shapes_2/alpha.tex | 73 ++++++++++++------- .../doc_tex/basic/Alpha_shapes_2/alpha.tex | 73 ++++++++++++------- .../include/CGAL/Alpha_shape_2.h | 32 +++++--- .../CGAL/IO/alpha_shapes_2_window_stream.h | 12 ++- .../include/CGAL/Weighted_alpha_shape_2.h | 54 ++++++++------ Packages/Alpha_shapes_2/version | 2 +- 6 files changed, 152 insertions(+), 94 deletions(-) diff --git a/Packages/Alpha_shapes_2/doc_tex/Alpha_shapes_2/alpha.tex b/Packages/Alpha_shapes_2/doc_tex/Alpha_shapes_2/alpha.tex index 03d451a54c4..fb2d67d5d21 100644 --- a/Packages/Alpha_shapes_2/doc_tex/Alpha_shapes_2/alpha.tex +++ b/Packages/Alpha_shapes_2/doc_tex/Alpha_shapes_2/alpha.tex @@ -222,7 +222,9 @@ Returns an output iterator which is the end of the constructed range.} \ccMethod{Classification_type classify(Face* f, int i, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index \ccStyle{i} of the underlying Delaunay triangulation with respect to \ccVar.} +{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index +\ccStyle{i} +of the underlying Delaunay triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Vertex* v, const Coord_type& alpha = get_alpha()) const;} @@ -260,7 +262,9 @@ greater than \ccStyle{alpha}.} \ccHeading{Operations} \ccMethod{int number_solid_components(const Coord_type& alpha = get_alpha()) const;} -{Returns the number of solid components of \ccVar, that is, the number of components of its regularized version.} +{Returns the number of solid components of \ccVar, that is, the number of +components of its +regularized version.} \ccMethod{Alpha_iterator find_optimal_alpha(int nb_components) const;} {Returns an iterator pointing to the first element with $\alpha$-value @@ -305,7 +309,8 @@ Delaunay triangulation are actually realized using \ccStyle{A.alpha find} uses linear search, while \ccStyle{A.alpha lower bound} and \ccStyle{A.alpha upper bound} use binary search. -\ccStyle{A.number solid components} performs a graph traversal and takes time linear in the number of faces of the underlying Delaunay triangulation. +\ccStyle{A.number solid components} performs a graph traversal and takes time +linear in the number of faces of the underlying Delaunay triangulation. \ccStyle{A.find optimal alpha} uses binary search and takes time $O(\mbox{\em number of faces } \log{\mbox{\em number of faces}})$. @@ -463,7 +468,9 @@ They are listed below as such. \ccHeading{Access Functions} \ccMethod{std::vector get_Range();} -{returns a vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three alpha values $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for +{returns a vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains +three alpha values + $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for $\alpha$ under $\alpha_3$, the edge is attached but singular, for $\alpha$ under $\alpha_2$, the face is regular, and for $\alpha$ under $\alpha_1$, the edge is interior.} @@ -473,7 +480,9 @@ face.} \ccModifiers \ccMethod{void Range(std::vector V);} -{sets the vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three alpha values $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for +{sets the vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three +alpha values + $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for $\alpha$ under $\alpha_3$, the edge is attached but singular, for $\alpha$ under $\alpha_2$, the face is regular, and for $\alpha$ under $\alpha_1$, the edge is interior.} @@ -500,12 +509,12 @@ for the Alpha Shape. The class \ccDefinition The class \ccClassTemplateName\ represents the family of $\alpha$-shapes of weighted points in a plane for {\em all} positive -$\alpha$. It maintains the underlying Regular triangulation which +$\alpha$. It maintains the underlying regular triangulation which represents connectivity and order among its faces. Each -$k$-dimensional face of the Regular triangulation is associated with +$k$-dimensional face of the regular triangulation is associated with an interval that specifies for which values of $\alpha$ the face belongs to the $\alpha$-shape. There are links between the intervals -and the $k$-dimensional faces of the Regular triangulation. +and the $k$-dimensional faces of the regular triangulation. \ccInclude{CGAL/Weighted_alpha_shape_2.h} @@ -523,7 +532,7 @@ the inherited functions. At the moment, only the static version is implemented. \ccNestedType{Gt}{the weighted alpha shape traits type.} -It contains the Regular triangulation traits class. For example +It contains the regular triangulation traits class. For example \ccStyle{Gt::Point} is a mapping on a weighted point class. Additionally, it defines a mapping on a coordinate type class. @@ -536,7 +545,7 @@ is \ccStyle{Coord_type}} \ccEnum{enum Classification_type {EXTERIOR, SINGULAR, REGULAR, INTERIOR};} {Distinguishes the different cases for classifying a $k$-dimensional face - of the underlying Regular triangulation of the $\alpha$-shape. \\ + of the underlying regular triangulation of the $\alpha$-shape. \\ \ccStyle{EXTERIOR} if the face does not belong to the $\alpha$-complex.\\ \ccStyle{SINGULAR} if the face belongs to the boundary of the $\alpha$-shape, but is not incident to any 2-dimensional face of the $\alpha$-complex\\ @@ -617,14 +626,14 @@ before initialization. % % \ccMethod{Vertex* insert(const Point& p);} % {Inserts point \ccStyle{p} in the alpha shape and returns the -% corresponding vertex of the underlying Regular triangulation.\\ If +% corresponding vertex of the underlying regular triangulation.\\ If % point \ccStyle{p} coincides with an already existing vertex, this % vertex is returned and the alpha shape remains unchanged.\\ Otherwise, -% the vertex is inserted in the underlying Regular triangulation and +% the vertex is inserted in the underlying regular triangulation and % the associated intervals are updated. } % % \ccMethod{void remove(Vertex *v);} -% {Removes the vertex from the underlying Regular triangulation. The +% {Removes the vertex from the underlying regular triangulation. The % created hole is retriangulated and the associated intervals are % updated.} % @@ -665,19 +674,20 @@ Returns an output iterator which is the end of the constructed range.} \ccMethod{Classification_type classify(Face* f, const Coord_type& alpha = get_alpha()) const;} -{Classifies the face \ccStyle{f} of the underlying Regular triangulation with respect to \ccVar.} +{Classifies the face \ccStyle{f} of the underlying regular triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(pair e, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge \ccStyle{e} of the underlying Regular triangulation with respect to \ccVar.} +{Classifies the edge \ccStyle{e} of the underlying regular triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Face* f, int i, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index \ccStyle{i} of the underlying Regular triangulation with respect to \ccVar.} +{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index +\ccStyle{i} of the underlying regular triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Vertex* v, const Coord_type& alpha = get_alpha()) const;} -{Classifies the vertex \ccStyle{v} of the underlying Regular triangulation with respect to \ccVar.} +{Classifies the vertex \ccStyle{v} of the underlying regular triangulation with respect to \ccVar.} \ccHeading{Traversal of the $\alpha$-Values} @@ -762,18 +772,19 @@ is an internal format. \ccImplementation In the first static version, the set of intervals associated with the -$k$-dimensional faces of the underlying Regular triangulation are +$k$-dimensional faces of the underlying regular triangulation are stored only as sorted \ccStyle{vectors}. By using an interval tree the alpha-shape could be constructed more efficiently. For the dynamic version, we need \ccStyle{multimaps} or dynamic interval trees. The cross links between the intervals and the $k$-dimensional faces of the -Regular triangulation are actually realized using +regular triangulation are actually realized using \ccStyle{multimaps} resp.\ \ccStyle{hash multimaps}. \ccStyle{A.alpha find} uses linear search, while \ccStyle{A.alpha lower bound} and \ccStyle{A.alpha upper bound} use binary search. -\ccStyle{A.number solid components} performs a graph traversal and takes time linear in the number of faces of the underlying Regular triangulation. +\ccStyle{A.number solid components} performs a graph traversal and takes time +linear in the number of faces of the underlying regular triangulation. \ccStyle{A.find optimal alpha} uses binary search and takes time $O(\mbox{\em number of faces } \log{\mbox{\em number of faces}})$. @@ -785,7 +796,7 @@ $O(\mbox{\em number of faces } \log{\mbox{\em number of faces}})$. \subsection{Requirements for the Alpha-Shape Traits Class} The class \ccStyle{Weighted_alpha_shape_2} parameterized with a -traits class, that has the same requirements as the Regular +traits class, that has the same requirements as the regular triangulation traits class. The following requirement catalog lists the primitives that must be defined additionally. @@ -797,7 +808,7 @@ the primitives that must be defined additionally. \ccDefinition A class \ccClassName\ that satisfies the requirements of a weighted alpha shape traits class must provide the following predicate and operations in -addition to the requirements for the Regular triangulation traits +addition to the requirements for the regular triangulation traits class. \ccTypes @@ -847,7 +858,7 @@ p1}.} The class \ccStyle{Weighted_alpha_shape_2} parameterized with a triangulation data structure class, that has exactly the same -requirements as the Regular triangulation triangulation data +requirements as the regular triangulation triangulation data structure class. But, she requires to be templated by special \ccc{Vertex} and @@ -883,7 +894,7 @@ type of a Weighted Alpha Shape offers additional functionalities to deal with th This additional functionalities related to the Weighted Alpha Shape are requirements which have to be fulfilled by the base face an Weighted Alpha Shape -in addition to the functionalities required by a Regular Triangulation Face +in addition to the functionalities required by a regular Triangulation Face They are listed below as such. @@ -893,14 +904,18 @@ They are listed below as such. \ccCreation \ccConstructor{Weighted_alpha_shape_face_base();}{default constructor.} \ccGlue -\ccConstructor{Weighted_alpha_shape_face_base(void* v0, void* v1, void* v2);}{constructor setting the incident vertices.} +\ccConstructor{Weighted_alpha_shape_face_base(void* v0, void* v1, void* +v2);}{constructor setting the incident vertices.} \ccGlue -\ccConstructor{Weighted_alpha_shape_face_base(void* v0, void* v1, void* v2, void* n0, void* n1, void* n2);} +\ccConstructor{Weighted_alpha_shape_face_base(void* v0, void* v1, void* v2, +void* n0, void* n1, void* n2);} {constructor setting the incident vertices and the neighboring faces.} \ccHeading{Access Functions} \ccMethod{std::vector get_Range();} -{returns a vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three alpha values $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for +{returns a vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains +three alpha values + $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for $\alpha$ under $\alpha_3$, the edge is attached but singular, for $\alpha$ under $\alpha_2$, the face is regular, and for $\alpha$ under $\alpha_1$, the edge is interior.} @@ -910,7 +925,9 @@ face.} \ccModifiers \ccMethod{void Range(std::vector V);} -{sets the vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three alpha values $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for +{sets the vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three +alpha values + $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for $\alpha$ under $\alpha_3$, the edge is attached but singular, for $\alpha$ under $\alpha_2$, the face is regular, and for $\alpha$ under $\alpha_1$, the edge is interior.} diff --git a/Packages/Alpha_shapes_2/doc_tex/basic/Alpha_shapes_2/alpha.tex b/Packages/Alpha_shapes_2/doc_tex/basic/Alpha_shapes_2/alpha.tex index 03d451a54c4..fb2d67d5d21 100644 --- a/Packages/Alpha_shapes_2/doc_tex/basic/Alpha_shapes_2/alpha.tex +++ b/Packages/Alpha_shapes_2/doc_tex/basic/Alpha_shapes_2/alpha.tex @@ -222,7 +222,9 @@ Returns an output iterator which is the end of the constructed range.} \ccMethod{Classification_type classify(Face* f, int i, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index \ccStyle{i} of the underlying Delaunay triangulation with respect to \ccVar.} +{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index +\ccStyle{i} +of the underlying Delaunay triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Vertex* v, const Coord_type& alpha = get_alpha()) const;} @@ -260,7 +262,9 @@ greater than \ccStyle{alpha}.} \ccHeading{Operations} \ccMethod{int number_solid_components(const Coord_type& alpha = get_alpha()) const;} -{Returns the number of solid components of \ccVar, that is, the number of components of its regularized version.} +{Returns the number of solid components of \ccVar, that is, the number of +components of its +regularized version.} \ccMethod{Alpha_iterator find_optimal_alpha(int nb_components) const;} {Returns an iterator pointing to the first element with $\alpha$-value @@ -305,7 +309,8 @@ Delaunay triangulation are actually realized using \ccStyle{A.alpha find} uses linear search, while \ccStyle{A.alpha lower bound} and \ccStyle{A.alpha upper bound} use binary search. -\ccStyle{A.number solid components} performs a graph traversal and takes time linear in the number of faces of the underlying Delaunay triangulation. +\ccStyle{A.number solid components} performs a graph traversal and takes time +linear in the number of faces of the underlying Delaunay triangulation. \ccStyle{A.find optimal alpha} uses binary search and takes time $O(\mbox{\em number of faces } \log{\mbox{\em number of faces}})$. @@ -463,7 +468,9 @@ They are listed below as such. \ccHeading{Access Functions} \ccMethod{std::vector get_Range();} -{returns a vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three alpha values $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for +{returns a vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains +three alpha values + $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for $\alpha$ under $\alpha_3$, the edge is attached but singular, for $\alpha$ under $\alpha_2$, the face is regular, and for $\alpha$ under $\alpha_1$, the edge is interior.} @@ -473,7 +480,9 @@ face.} \ccModifiers \ccMethod{void Range(std::vector V);} -{sets the vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three alpha values $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for +{sets the vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three +alpha values + $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for $\alpha$ under $\alpha_3$, the edge is attached but singular, for $\alpha$ under $\alpha_2$, the face is regular, and for $\alpha$ under $\alpha_1$, the edge is interior.} @@ -500,12 +509,12 @@ for the Alpha Shape. The class \ccDefinition The class \ccClassTemplateName\ represents the family of $\alpha$-shapes of weighted points in a plane for {\em all} positive -$\alpha$. It maintains the underlying Regular triangulation which +$\alpha$. It maintains the underlying regular triangulation which represents connectivity and order among its faces. Each -$k$-dimensional face of the Regular triangulation is associated with +$k$-dimensional face of the regular triangulation is associated with an interval that specifies for which values of $\alpha$ the face belongs to the $\alpha$-shape. There are links between the intervals -and the $k$-dimensional faces of the Regular triangulation. +and the $k$-dimensional faces of the regular triangulation. \ccInclude{CGAL/Weighted_alpha_shape_2.h} @@ -523,7 +532,7 @@ the inherited functions. At the moment, only the static version is implemented. \ccNestedType{Gt}{the weighted alpha shape traits type.} -It contains the Regular triangulation traits class. For example +It contains the regular triangulation traits class. For example \ccStyle{Gt::Point} is a mapping on a weighted point class. Additionally, it defines a mapping on a coordinate type class. @@ -536,7 +545,7 @@ is \ccStyle{Coord_type}} \ccEnum{enum Classification_type {EXTERIOR, SINGULAR, REGULAR, INTERIOR};} {Distinguishes the different cases for classifying a $k$-dimensional face - of the underlying Regular triangulation of the $\alpha$-shape. \\ + of the underlying regular triangulation of the $\alpha$-shape. \\ \ccStyle{EXTERIOR} if the face does not belong to the $\alpha$-complex.\\ \ccStyle{SINGULAR} if the face belongs to the boundary of the $\alpha$-shape, but is not incident to any 2-dimensional face of the $\alpha$-complex\\ @@ -617,14 +626,14 @@ before initialization. % % \ccMethod{Vertex* insert(const Point& p);} % {Inserts point \ccStyle{p} in the alpha shape and returns the -% corresponding vertex of the underlying Regular triangulation.\\ If +% corresponding vertex of the underlying regular triangulation.\\ If % point \ccStyle{p} coincides with an already existing vertex, this % vertex is returned and the alpha shape remains unchanged.\\ Otherwise, -% the vertex is inserted in the underlying Regular triangulation and +% the vertex is inserted in the underlying regular triangulation and % the associated intervals are updated. } % % \ccMethod{void remove(Vertex *v);} -% {Removes the vertex from the underlying Regular triangulation. The +% {Removes the vertex from the underlying regular triangulation. The % created hole is retriangulated and the associated intervals are % updated.} % @@ -665,19 +674,20 @@ Returns an output iterator which is the end of the constructed range.} \ccMethod{Classification_type classify(Face* f, const Coord_type& alpha = get_alpha()) const;} -{Classifies the face \ccStyle{f} of the underlying Regular triangulation with respect to \ccVar.} +{Classifies the face \ccStyle{f} of the underlying regular triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(pair e, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge \ccStyle{e} of the underlying Regular triangulation with respect to \ccVar.} +{Classifies the edge \ccStyle{e} of the underlying regular triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Face* f, int i, const Coord_type& alpha = get_alpha()) const;} -{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index \ccStyle{i} of the underlying Regular triangulation with respect to \ccVar.} +{Classifies the edge of the face \ccStyle{f} opposite to the vertex with index +\ccStyle{i} of the underlying regular triangulation with respect to \ccVar.} \ccMethod{Classification_type classify(Vertex* v, const Coord_type& alpha = get_alpha()) const;} -{Classifies the vertex \ccStyle{v} of the underlying Regular triangulation with respect to \ccVar.} +{Classifies the vertex \ccStyle{v} of the underlying regular triangulation with respect to \ccVar.} \ccHeading{Traversal of the $\alpha$-Values} @@ -762,18 +772,19 @@ is an internal format. \ccImplementation In the first static version, the set of intervals associated with the -$k$-dimensional faces of the underlying Regular triangulation are +$k$-dimensional faces of the underlying regular triangulation are stored only as sorted \ccStyle{vectors}. By using an interval tree the alpha-shape could be constructed more efficiently. For the dynamic version, we need \ccStyle{multimaps} or dynamic interval trees. The cross links between the intervals and the $k$-dimensional faces of the -Regular triangulation are actually realized using +regular triangulation are actually realized using \ccStyle{multimaps} resp.\ \ccStyle{hash multimaps}. \ccStyle{A.alpha find} uses linear search, while \ccStyle{A.alpha lower bound} and \ccStyle{A.alpha upper bound} use binary search. -\ccStyle{A.number solid components} performs a graph traversal and takes time linear in the number of faces of the underlying Regular triangulation. +\ccStyle{A.number solid components} performs a graph traversal and takes time +linear in the number of faces of the underlying regular triangulation. \ccStyle{A.find optimal alpha} uses binary search and takes time $O(\mbox{\em number of faces } \log{\mbox{\em number of faces}})$. @@ -785,7 +796,7 @@ $O(\mbox{\em number of faces } \log{\mbox{\em number of faces}})$. \subsection{Requirements for the Alpha-Shape Traits Class} The class \ccStyle{Weighted_alpha_shape_2} parameterized with a -traits class, that has the same requirements as the Regular +traits class, that has the same requirements as the regular triangulation traits class. The following requirement catalog lists the primitives that must be defined additionally. @@ -797,7 +808,7 @@ the primitives that must be defined additionally. \ccDefinition A class \ccClassName\ that satisfies the requirements of a weighted alpha shape traits class must provide the following predicate and operations in -addition to the requirements for the Regular triangulation traits +addition to the requirements for the regular triangulation traits class. \ccTypes @@ -847,7 +858,7 @@ p1}.} The class \ccStyle{Weighted_alpha_shape_2} parameterized with a triangulation data structure class, that has exactly the same -requirements as the Regular triangulation triangulation data +requirements as the regular triangulation triangulation data structure class. But, she requires to be templated by special \ccc{Vertex} and @@ -883,7 +894,7 @@ type of a Weighted Alpha Shape offers additional functionalities to deal with th This additional functionalities related to the Weighted Alpha Shape are requirements which have to be fulfilled by the base face an Weighted Alpha Shape -in addition to the functionalities required by a Regular Triangulation Face +in addition to the functionalities required by a regular Triangulation Face They are listed below as such. @@ -893,14 +904,18 @@ They are listed below as such. \ccCreation \ccConstructor{Weighted_alpha_shape_face_base();}{default constructor.} \ccGlue -\ccConstructor{Weighted_alpha_shape_face_base(void* v0, void* v1, void* v2);}{constructor setting the incident vertices.} +\ccConstructor{Weighted_alpha_shape_face_base(void* v0, void* v1, void* +v2);}{constructor setting the incident vertices.} \ccGlue -\ccConstructor{Weighted_alpha_shape_face_base(void* v0, void* v1, void* v2, void* n0, void* n1, void* n2);} +\ccConstructor{Weighted_alpha_shape_face_base(void* v0, void* v1, void* v2, +void* n0, void* n1, void* n2);} {constructor setting the incident vertices and the neighboring faces.} \ccHeading{Access Functions} \ccMethod{std::vector get_Range();} -{returns a vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three alpha values $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for +{returns a vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains +three alpha values + $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for $\alpha$ under $\alpha_3$, the edge is attached but singular, for $\alpha$ under $\alpha_2$, the face is regular, and for $\alpha$ under $\alpha_1$, the edge is interior.} @@ -910,7 +925,9 @@ face.} \ccModifiers \ccMethod{void Range(std::vector V);} -{sets the vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three alpha values $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for +{sets the vector \ccc{V}, in which, for each edge $i$, \ccc{V[i]} contains three +alpha values + $\alpha_1 \leq \alpha_2 \leq \alpha_3$, such as for $\alpha$ under $\alpha_3$, the edge is attached but singular, for $\alpha$ under $\alpha_2$, the face is regular, and for $\alpha$ under $\alpha_1$, the edge is interior.} diff --git a/Packages/Alpha_shapes_2/include/CGAL/Alpha_shape_2.h b/Packages/Alpha_shapes_2/include/CGAL/Alpha_shape_2.h index ff5535af130..7d01eea984d 100644 --- a/Packages/Alpha_shapes_2/include/CGAL/Alpha_shape_2.h +++ b/Packages/Alpha_shapes_2/include/CGAL/Alpha_shape_2.h @@ -862,9 +862,11 @@ Alpha_shape_2::Output () // regular means incident to a higher-dimensional face // thus we would write to many vertices L.push_back((segment((*edge_alpha_it).second.first, - (*edge_alpha_it).second.second)).source()); + (*edge_alpha_it).second.second)) + .source()); L.push_back((segment((*edge_alpha_it).second.first, - (*edge_alpha_it).second.second)).target()); + (*edge_alpha_it).second.second)) + .target()); } } } @@ -900,9 +902,11 @@ Alpha_shape_2::Output () (*edge_alpha_it).second.second) == REGULAR)); L.push_back((segment((*edge_alpha_it).second.first, - (*edge_alpha_it).second.second)).source()); + (*edge_alpha_it).second.second)) + .source()); L.push_back((segment((*edge_alpha_it).second.first, - (*edge_alpha_it).second.second)).target()); + (*edge_alpha_it).second.second)) + .target()); } } else @@ -922,9 +926,11 @@ Alpha_shape_2::Output () (*edge_alpha_it).second.second) == SINGULAR))); L.push_back((segment((*edge_alpha_it).second.first, - (*edge_alpha_it).second.second)).source()); + (*edge_alpha_it).second.second)) + .source()); L.push_back((segment((*edge_alpha_it).second.first, - (*edge_alpha_it).second.second)).target()); + (*edge_alpha_it).second.second)) + .target()); } } @@ -1275,7 +1281,8 @@ std::back_insert_iterator::Vertex_handle > > Alpha_shape_2::get_Alpha_shape_vertices (std::back_insert_iterator > result) const { - //typedef typename Alpha_shape_2::Interval_vertex_map Interval_vertex_map; + //typedef typename Alpha_shape_2::Interval_vertex_map + // Interval_vertex_map; typename Interval_vertex_map::const_iterator vertex_alpha_it; //const typename Alpha_shape_2::Interval2* pInterval2; @@ -1325,8 +1332,8 @@ Alpha_shape_2::get_Alpha_shape_vertices template < class Gt, class Tds > std::back_insert_iterator::Face_handle, int > > > -Alpha_shape_2::get_Alpha_shape_edges(std::back_insert_iterator > > result) const +Alpha_shape_2::get_Alpha_shape_edges(std::back_insert_iterator + > > result) const { // Writes the edges of the alpha shape `A' for the current $\alpha$-value // to the container where 'out' refers to. Returns an output iterator @@ -1498,7 +1505,7 @@ Alpha_shape_2::classify( Vertex_handle v, template < class Gt, class Tds > int -Alpha_shape_2::number_solid_components(const Coord_type& alpha) const +Alpha_shape_2::number_solid_components(const Coord_type& alpha) const { // Determine the number of connected solid components // takes time O(#alpha_shape) amortized if STL_STD::HASH_TABLES @@ -1877,8 +1884,9 @@ Alpha_shape_2::op_ostream(std::ostream& os) const } else - { // pInterval->second == INFINITY || pInterval->second >= get_alpha()) - // pInterval->second == INFINITY happens only for convex hull + { // pInterval->second == INFINITY || + // pInterval->second >= get_alpha()) + // pInterval->second == INFINITY happens only for convex hull // of dimension 1 thus singular // write the singular edges diff --git a/Packages/Alpha_shapes_2/include/CGAL/IO/alpha_shapes_2_window_stream.h b/Packages/Alpha_shapes_2/include/CGAL/IO/alpha_shapes_2_window_stream.h index 219c1924aec..d270d438eb7 100644 --- a/Packages/Alpha_shapes_2/include/CGAL/IO/alpha_shapes_2_window_stream.h +++ b/Packages/Alpha_shapes_2/include/CGAL/IO/alpha_shapes_2_window_stream.h @@ -34,10 +34,12 @@ Window_stream& Alpha_shape_2::op_window(Window_stream& W) const { - typedef typename Alpha_shape_2::Interval_vertex_map Interval_vertex_map; + typedef typename Alpha_shape_2::Interval_vertex_map + Interval_vertex_map; typename Interval_vertex_map::const_iterator vertex_alpha_it; - typedef typename Alpha_shape_2::Interval_edge_map Interval_edge_map; + typedef typename Alpha_shape_2::Interval_edge_map + Interval_edge_map; typename Interval_edge_map::const_iterator edge_alpha_it; const typename Alpha_shape_2::Interval3* pInterval; @@ -181,12 +183,14 @@ Weighted_alpha_shape_2::op_window(Window_stream& W) const { typedef - typename Weighted_alpha_shape_2::Interval_vertex_map Interval_vertex_map; + typename Weighted_alpha_shape_2::Interval_vertex_map + Interval_vertex_map; typename Interval_vertex_map::const_iterator vertex_alpha_it; typedef - typename Weighted_alpha_shape_2::Interval_edge_map Interval_edge_map; + typename Weighted_alpha_shape_2::Interval_edge_map + Interval_edge_map; typename Interval_edge_map::const_iterator edge_alpha_it; diff --git a/Packages/Alpha_shapes_2/include/CGAL/Weighted_alpha_shape_2.h b/Packages/Alpha_shapes_2/include/CGAL/Weighted_alpha_shape_2.h index 0f52cdd6ee4..f2cc98442fa 100644 --- a/Packages/Alpha_shapes_2/include/CGAL/Weighted_alpha_shape_2.h +++ b/Packages/Alpha_shapes_2/include/CGAL/Weighted_alpha_shape_2.h @@ -888,9 +888,11 @@ Weighted_alpha_shape_2::Output () // regular means incident to a higher-dimensional face // thus we would write to many vertices L.push_back(((*edge_alpha_it).second.first-> - vertex(cw((*edge_alpha_it).second.second)))->point()); + vertex(cw((*edge_alpha_it).second.second))) + ->point()); L.push_back(((*edge_alpha_it).second.first-> - vertex(ccw((*edge_alpha_it).second.second)))->point()); + vertex(ccw((*edge_alpha_it).second.second))) + ->point()); } } } @@ -926,9 +928,11 @@ Weighted_alpha_shape_2::Output () (*edge_alpha_it).second.second) == REGULAR)); L.push_back(((*edge_alpha_it).second.first-> - vertex(cw((*edge_alpha_it).second.second)))->point()); + vertex(cw((*edge_alpha_it).second.second))) + ->point()); L.push_back(((*edge_alpha_it).second.first-> - vertex(ccw((*edge_alpha_it).second.second)))->point()); + vertex(ccw((*edge_alpha_it).second.second))) + ->point()); } } else @@ -948,9 +952,11 @@ Weighted_alpha_shape_2::Output () (*edge_alpha_it).second.second) == SINGULAR))); L.push_back(((*edge_alpha_it).second.first-> - vertex(cw((*edge_alpha_it).second.second)))->point()); + vertex(cw((*edge_alpha_it).second.second))) + ->point()); L.push_back(((*edge_alpha_it).second.first-> - vertex(ccw((*edge_alpha_it).second.second)))->point()); + vertex(ccw((*edge_alpha_it).second.second))) + ->point()); } } @@ -992,9 +998,9 @@ Weighted_alpha_shape_2::initialize_weighted_points_to_the_nearest_vorono Point p=D.dual(f); // double // dd=(p.point().x()-(*point_it).point().x())* - // (p.point().x()-(*point_it).point().x()) + // (p.point().x()-(*point_it).point().x()) //+(p.point().y()-(*point_it).point().y())* - // (p.point().y()-(*point_it).point().y()); + // (p.point().y()-(*point_it).point().y()); double dd=squared_distance(p,(*point_it)); d=std::min(dd,d); } @@ -1232,11 +1238,13 @@ Weighted_alpha_shape_2::initialize_interval_edge_map(void) if (!is_infinite(pNeighbor)) { - interval = (is_attached(pNeighbor, pNeighbor->index(&(*pFace)))) ? + interval = (is_attached(pNeighbor, + pNeighbor->index(&(*pFace)))) ? make_triple(UNDEFINED, find_interval(pNeighbor), INFINITY): - make_triple(smallest_power(pNeighbor, pNeighbor->index(&(*pFace))), + make_triple(smallest_power(pNeighbor, + pNeighbor->index(&(*pFace))), find_interval(pNeighbor), INFINITY); } @@ -1244,7 +1252,8 @@ Weighted_alpha_shape_2::initialize_interval_edge_map(void) { // both faces are infinite by definition unattached // the edge is finite by construction - CGAL_triangulation_precondition((is_infinite(pNeighbor) && is_infinite(pFace))); + CGAL_triangulation_precondition((is_infinite(pNeighbor) && + is_infinite(pFace))); interval = make_triple(smallest_power(pFace, i), INFINITY, INFINITY); @@ -1252,7 +1261,8 @@ Weighted_alpha_shape_2::initialize_interval_edge_map(void) } else { // is_infinite(pNeighbor) - CGAL_triangulation_precondition((is_infinite(pNeighbor) && !is_infinite(pFace))); + CGAL_triangulation_precondition((is_infinite(pNeighbor) && + !is_infinite(pFace))); if (is_attached(pFace, i)) interval = make_triple(UNDEFINED, find_interval(pFace), @@ -1482,12 +1492,14 @@ Weighted_alpha_shape_2::initialize_alpha_spectrum(void) //----------------------------------------------------------------------- template -std::back_insert_iterator::Vertex_handle > > +std::back_insert_iterator +::Vertex_handle > > Weighted_alpha_shape_2::get_Alpha_shape_vertices( - std::back_insert_iterator > result) const + std::back_insert_iterator > result) const { - //typedef typename Alpha_shape_2::Interval_vertex_map Interval_vertex_map; + //typedef typename Alpha_shape_2::Interval_vertex_map + // Interval_vertex_map; typename Interval_vertex_map::const_iterator vertex_alpha_it; //const typename Alpha_shape_2::Interval2* pInterval2; @@ -1538,10 +1550,10 @@ Weighted_alpha_shape_2::get_Alpha_shape_vertices( //----------------------------------------------------------------------- template -std::back_insert_iterator -::Face_handle, int > > > -Weighted_alpha_shape_2::get_Alpha_shape_edges -(std::back_insert_iterator > > result) const +std::back_insert_iterator::Face_handle, int > > > +Weighted_alpha_shape_2::get_Alpha_shape_edges(std::back_insert_iterator + > > result) const { // Writes the edges of the alpha shape `A' for the current $\alpha$-value // to the container where 'out' refers to. Returns an output iterator @@ -2112,8 +2124,8 @@ Weighted_alpha_shape_2::op_ostream (std::ostream& os) const else { // pInterval->second == A.INFINITY || // pInterval->second >= A.get_alpha()) - // pInterval->second == A.INFINITY happens only for convex hull - // of dimension 1 thus singular + // pInterval->second == A.INFINITY happens only for convex + // hull of dimension 1 thus singular // write the singular edges if (pInterval->first != A.UNDEFINED) diff --git a/Packages/Alpha_shapes_2/version b/Packages/Alpha_shapes_2/version index 884135aabad..3f16ea7dfb3 100644 --- a/Packages/Alpha_shapes_2/version +++ b/Packages/Alpha_shapes_2/version @@ -1 +1 @@ -1.6 (27 Oct 1999) +1.6.1 (27 Oct 1999)