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

minor corrections.

This commit is contained in:
Tran Kai Frank Da 1999-10-27 13:50:17 +00:00
parent b905d27a75
commit 77b21c65ef
6 changed files with 152 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
Packages/Alpha_shapes_2/doc_tex/Alpha_shapes_2/alpha.tex
View File

@ -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<Interval3> 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<Interval3> 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<Face*, int> 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<Gt,Tds>} 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<Gt,Tds>} 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<Interval3> 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<Interval3> 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.}

73
Packages/Alpha_shapes_2/doc_tex/basic/Alpha_shapes_2/alpha.tex
View File

@ -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<Interval3> 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<Interval3> 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<Face*, int> 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<Gt,Tds>} 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<Gt,Tds>} 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<Interval3> 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<Interval3> 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.}

32
Packages/Alpha_shapes_2/include/CGAL/Alpha_shape_2.h
View File

@ -862,9 +862,11 @@ Alpha_shape_2<Gt,Tds>::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<Gt,Tds>::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<Gt,Tds>::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<std::list<Alpha_shape_2<Gt,Tds>::Vertex_handle > >
Alpha_shape_2<Gt,Tds>::get_Alpha_shape_vertices
(std::back_insert_iterator<std::list<Vertex_handle > > result) const
{
//typedef typename Alpha_shape_2<Gt,Tds>::Interval_vertex_map Interval_vertex_map;
//typedef typename Alpha_shape_2<Gt,Tds>::Interval_vertex_map
// Interval_vertex_map;
typename Interval_vertex_map::const_iterator vertex_alpha_it;
//const typename Alpha_shape_2<Gt,Tds>::Interval2* pInterval2;
@ -1325,8 +1332,8 @@ Alpha_shape_2<Gt,Tds>::get_Alpha_shape_vertices
template < class Gt, class Tds >
std::back_insert_iterator<std::list
<std::pair<Alpha_shape_2<Gt,Tds>::Face_handle, int > > >
Alpha_shape_2<Gt,Tds>::get_Alpha_shape_edges(std::back_insert_iterator<std::list
<std::pair<Face_handle, int > > > result) const
Alpha_shape_2<Gt,Tds>::get_Alpha_shape_edges(std::back_insert_iterator
<std::list<std::pair<Face_handle, int > > > 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<Gt,Tds>::classify( Vertex_handle v,
template < class Gt, class Tds >
int
Alpha_shape_2<Gt,Tds>::number_solid_components(const Coord_type& alpha) const
Alpha_shape_2<Gt,Tds>::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<Gt,Tds>::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

12
Packages/Alpha_shapes_2/include/CGAL/IO/alpha_shapes_2_window_stream.h
View File

@ -34,10 +34,12 @@ Window_stream&
Alpha_shape_2<Gt,Tds>::op_window(Window_stream& W) const
{
typedef typename Alpha_shape_2<Gt,Tds>::Interval_vertex_map Interval_vertex_map;
typedef typename Alpha_shape_2<Gt,Tds>::Interval_vertex_map
Interval_vertex_map;
typename Interval_vertex_map::const_iterator vertex_alpha_it;
typedef typename Alpha_shape_2<Gt,Tds>::Interval_edge_map Interval_edge_map;
typedef typename Alpha_shape_2<Gt,Tds>::Interval_edge_map
Interval_edge_map;
typename Interval_edge_map::const_iterator edge_alpha_it;
const typename Alpha_shape_2<Gt,Tds>::Interval3* pInterval;
@ -181,12 +183,14 @@ Weighted_alpha_shape_2<Gt,Tds>::op_window(Window_stream& W) const
{
typedef
typename Weighted_alpha_shape_2<Gt,Tds>::Interval_vertex_map Interval_vertex_map;
typename Weighted_alpha_shape_2<Gt,Tds>::Interval_vertex_map
Interval_vertex_map;
typename Interval_vertex_map::const_iterator vertex_alpha_it;
typedef
typename Weighted_alpha_shape_2<Gt,Tds>::Interval_edge_map Interval_edge_map;
typename Weighted_alpha_shape_2<Gt,Tds>::Interval_edge_map
Interval_edge_map;
typename Interval_edge_map::const_iterator edge_alpha_it;

54
Packages/Alpha_shapes_2/include/CGAL/Weighted_alpha_shape_2.h
View File

@ -888,9 +888,11 @@ Weighted_alpha_shape_2<Gt,Tds>::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<Gt,Tds>::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<Gt,Tds>::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<Gt,Tds>::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<Gt,Tds>::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<Gt,Tds>::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<Gt,Tds>::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<Gt,Tds>::initialize_alpha_spectrum(void)
//-----------------------------------------------------------------------
template<class Gt, class Tds>
std::back_insert_iterator<std::list< Weighted_alpha_shape_2<Gt,Tds>::Vertex_handle > >
std::back_insert_iterator
<std::list< Weighted_alpha_shape_2<Gt,Tds>::Vertex_handle > >
Weighted_alpha_shape_2<Gt,Tds>::get_Alpha_shape_vertices(
std::back_insert_iterator<std::list<Vertex_handle > > result) const
std::back_insert_iterator<std::list<Vertex_handle > > result) const
{
//typedef typename Alpha_shape_2<Gt,Tds>::Interval_vertex_map Interval_vertex_map;
//typedef typename Alpha_shape_2<Gt,Tds>::Interval_vertex_map
// Interval_vertex_map;
typename Interval_vertex_map::const_iterator vertex_alpha_it;
//const typename Alpha_shape_2<Gt,Tds>::Interval2* pInterval2;
@ -1538,10 +1550,10 @@ Weighted_alpha_shape_2<Gt,Tds>::get_Alpha_shape_vertices(
//-----------------------------------------------------------------------
template<class Gt, class Tds>
std::back_insert_iterator
<std::list<std::pair<typename Weighted_alpha_shape_2<Gt,Tds>::Face_handle, int > > >
Weighted_alpha_shape_2<Gt,Tds>::get_Alpha_shape_edges
(std::back_insert_iterator<std::list<std::pair< Face_handle, int > > > result) const
std::back_insert_iterator<std::list
<std::pair<typename Weighted_alpha_shape_2<Gt,Tds>::Face_handle, int > > >
Weighted_alpha_shape_2<Gt,Tds>::get_Alpha_shape_edges(std::back_insert_iterator
<std::list<std::pair< Face_handle, int > > > 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<Gt,Tds>::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)

2
Packages/Alpha_shapes_2/version
View File

@ -1 +1 @@
1.6 (27 Oct 1999)
1.6.1 (27 Oct 1999)