mirror of https://github.com/CGAL/cgal
CGAL: An Halfedge (#9119)
## Summary of Changes Replace several "an" by "a" ## Release Management * Affected package(s): global * License and copyright ownership: unchanged
This commit is contained in:
Sebastien Loriot
GitHub
commit
8a136c50c9
|
|
@ -221,7 +221,7 @@ a visible circle through an iterator called
|
|||
`ApolloniusGraphVertexBase_2` concept and is implemented by its
|
||||
model, the `Apollonius_graph_vertex_base_2<Gt,StoreHidden>`
|
||||
class. It is also possible to iterate through the entire set of hidden
|
||||
sites using an homonymous iterator defined by the
|
||||
sites using a homonymous iterator defined by the
|
||||
`Apollonius_graph_2<Gt,Agds>` class.
|
||||
|
||||
Since storing hidden sites may not be of interest in some cases (e.g.,
|
||||
|
|
|
|||
|
|
@ -56,7 +56,7 @@ public:
|
|||
/// @{
|
||||
|
||||
/*!
|
||||
Creates an hierarchy of Apollonius graphs using `gt` as
|
||||
Creates a hierarchy of Apollonius graphs using `gt` as
|
||||
geometric traits.
|
||||
*/
|
||||
Apollonius_graph_hierarchy_2(Gt gt=Gt());
|
||||
|
|
|
|||
|
|
@ -4890,7 +4890,7 @@ using Arrangement = CGAL::Arrangement_2<Traits>;
|
|||
|
||||
<!-- ----------------------------------------------------------------------- -->
|
||||
\cgalFigureBegin{aos_fig-conic_multiplicities,conic_multiplicities.png}
|
||||
An arrangement of a circular arc and an hyperbolic arc, as constructed
|
||||
An arrangement of a circular arc and a hyperbolic arc, as constructed
|
||||
in \ref Arrangement_on_surface_2/conic_multiplicities.cpp.
|
||||
\cgalFigureEnd
|
||||
<!-- ----------------------------------------------------------------------- -->
|
||||
|
|
|
|||
|
|
@ -136,7 +136,7 @@ public:
|
|||
/// \name Face Creation
|
||||
/// The following function is invoked whenever a new face is
|
||||
/// created. It is guaranteed that all halfedges along the face
|
||||
/// boundary have already been created an have their auxiliary data
|
||||
/// boundary have already been created and have their auxiliary data
|
||||
/// fields attached to them:
|
||||
/// @{
|
||||
|
||||
|
|
|
|||
|
|
@ -685,7 +685,7 @@ point_position(const Point_2& p, Bezier_cache& cache) const
|
|||
return EQUAL;
|
||||
}
|
||||
|
||||
// Then check whether the bezier is an horizontal segment or
|
||||
// Then check whether the bezier is a horizontal segment or
|
||||
// if p has the same x-coordinate as one of the endpoint
|
||||
|
||||
const Comparison_result res1 = p.compare_x(_ps, cache);
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ the dot operator, and a typical usage is thus:
|
|||
|
||||
\code {.cpp}
|
||||
Graph g1, g2;
|
||||
Vertex_point_map_2 vpm_2; // an hypothetical custom property map assigning a Point to the vertices of g2
|
||||
Vertex_point_map_2 vpm_2; // a hypothetical custom property map assigning a Point to the vertices of g2
|
||||
|
||||
// without any named parameter (default values are used)
|
||||
CGAL::copy_face_graph(g1, g2);
|
||||
|
|
|
|||
|
|
@ -1896,7 +1896,7 @@ bool satisfies_link_condition(typename boost::graph_traits<Graph>::edge_descript
|
|||
* \param h halfedge descriptor
|
||||
* \param g the graph
|
||||
*
|
||||
* \returns an halfedge linking the two vertices adjacent to the vertex being removed.
|
||||
* \returns a halfedge linking the two vertices adjacent to the vertex being removed.
|
||||
*
|
||||
* \pre `degree(target(h, g), g) == 2`.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -537,7 +537,7 @@ bool is_valid_polygon_mesh(const Mesh& g, bool verb = false)
|
|||
return false;
|
||||
|
||||
// test for 2-manifoldness
|
||||
// Distinct facets on each side of an halfedge.
|
||||
// Distinct facets on each side of a halfedge.
|
||||
for(halfedge_descriptor i : halfedges(g))
|
||||
{
|
||||
valid = (face(i, g) != face(opposite(i, g), g));
|
||||
|
|
|
|||
|
|
@ -1193,7 +1193,7 @@ protected:
|
|||
|
||||
// accessor for low-level arrangement functionalities
|
||||
CGAL::Arr_accessor<Aos_2> accessor(*arr);
|
||||
// the face field of outer and inner ccb are used in the loop to access the old face an halfedge
|
||||
// the face field of outer and inner ccb are used in the loop to access the old face a halfedge
|
||||
// used to contribute to. These two vectors are used to delay the association to the new face to
|
||||
// avoid overwriting a field that is still needed
|
||||
typedef std::pair<typename Aos_2::Dcel::Outer_ccb*, typename Aos_2::Dcel::Face*> Outer_ccb_and_face;
|
||||
|
|
|
|||
|
|
@ -116,13 +116,13 @@ Draws a theta-graph with k cones
|
|||
<li><b>Yao-k-graph:</b>
|
||||
Draws a Yao-graph with k cones
|
||||
<li><b>Half-theta-k-graph with even cones:</b>
|
||||
Draws an half-theta-graph with the even of k cones.
|
||||
Draws a half-theta-graph with the even of k cones.
|
||||
<li><b>Half-Yao-k-graph with even cones:</b>
|
||||
Draws an half-Yao-graph with the even of k cones.
|
||||
Draws a half-Yao-graph with the even of k cones.
|
||||
<li><b>Half-theta-k-graph with odd cones:</b>
|
||||
Draws an half-theta-graph with the odd of k cones.
|
||||
Draws a half-theta-graph with the odd of k cones.
|
||||
<li><b>Half-Yao-k-graph with odd cones:</b>
|
||||
Draws an half-Yao-graph with the odd of k cones.
|
||||
Draws a half-Yao-graph with the odd of k cones.
|
||||
<li><b>k cones:</b> For each selected point.
|
||||
Draws the k cones around the point.
|
||||
</ul>
|
||||
|
|
|
|||
|
|
@ -472,7 +472,7 @@ The output is:
|
|||
Number of 2-free darts: 4
|
||||
\endverbatim
|
||||
|
||||
We can verify that there are 6 2-cells after the insertion since the squared face was inserted as a hole in one face of the hexahedron. We can also see that there are 4 2-free darts, which are the darts of the squared face. Since they bound an hole, there is no face filling the hole and thus 4 darts are 2-free.
|
||||
We can verify that there are 6 2-cells after the insertion since the squared face was inserted as a hole in one face of the hexahedron. We can also see that there are 4 2-free darts, which are the darts of the squared face. Since they bound a hole, there is no face filling the hole and thus 4 darts are 2-free.
|
||||
|
||||
See also a similar example for Linear cell complex \ref Linear_cell_complexInsert "Insert an Edge Between Two Different Faces".
|
||||
|
||||
|
|
|
|||
|
|
@ -572,7 +572,7 @@ namespace CGAL {
|
|||
}
|
||||
}
|
||||
|
||||
/** Import the given hds which should be a model of an halfedge graph. */
|
||||
/** Import the given hds which should be a model of a halfedge graph. */
|
||||
template<class HEG>
|
||||
void import_from_halfedge_graph(const HEG& heg,
|
||||
std::unordered_map
|
||||
|
|
@ -3710,8 +3710,8 @@ namespace CGAL {
|
|||
void set_automatic_attributes_management_without_correction(bool newval)
|
||||
{ this->automatic_attributes_management = newval; }
|
||||
|
||||
/** Create an half-edge.
|
||||
* @return a dart of the new half-edge.
|
||||
/** Create a halfedge.
|
||||
* @return a dart of the new halfedge.
|
||||
*/
|
||||
Dart_descriptor make_half_edge()
|
||||
{ return create_dart(); }
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ In any way, a package has to work with both representations.
|
|||
Since \cgal uses homogeneous representation for affine geometry and not
|
||||
for projective geometry, the homogenizing coordinate is non zero.
|
||||
The cartesian
|
||||
representation corresponding to an homogeneous point
|
||||
representation corresponding to a homogeneous point
|
||||
\f$ (x_0,x_1,...,x_d,w)\f$ is
|
||||
\f$ (x_0/w,x_1/w,...,x_d/w)\f$. Hence, homogeneous representation is not unique;
|
||||
\f$ (\alpha x,\alpha y,\alpha z,\alpha w)\f$ is an alternative
|
||||
|
|
|
|||
|
|
@ -494,7 +494,7 @@ The output is:
|
|||
Number of 2-free darts: 8
|
||||
\endverbatim
|
||||
|
||||
We can verify that there are 6 2-cells after the insertion since the squared face was inserted as a hole in one face of the hexahedron. We can also see that there are 8 2-free darts, which are the darts of the squared face. Since they bound an hole, there is no face filling the hole and thus 8 darts are 2-free.
|
||||
We can verify that there are 6 2-cells after the insertion since the squared face was inserted as a hole in one face of the hexahedron. We can also see that there are 8 2-free darts, which are the darts of the squared face. Since they bound a hole, there is no face filling the hole and thus 8 darts are 2-free.
|
||||
|
||||
See also a similar example for Linear cell complex \ref Linear_cell_complexInsert "Insert an Edge Between Two Different Faces".
|
||||
|
||||
|
|
|
|||
|
|
@ -2949,8 +2949,8 @@ namespace CGAL {
|
|||
void set_automatic_attributes_management_without_correction(bool newval)
|
||||
{ this->automatic_attributes_management = newval; }
|
||||
|
||||
/** Create an half-edge.
|
||||
* @return a dart of the new half-edge.
|
||||
/** Create a halfedge.
|
||||
* @return a dart of the new halfedge.
|
||||
*/
|
||||
Dart_descriptor make_half_edge()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -103,7 +103,7 @@ namespace CGAL {
|
|||
/*!
|
||||
|
||||
The class `Random_points_in_cube_d` is an input iterator creating points uniformly
|
||||
distributed in an half-open cube.
|
||||
distributed in a half-open cube.
|
||||
|
||||
\cgalModels{InputIterator,PointGenerator}
|
||||
|
||||
|
|
|
|||
|
|
@ -222,7 +222,7 @@ private:
|
|||
QTimer flyTimer_;
|
||||
|
||||
bool rotatesAroundUpVector_;
|
||||
// Inverse the direction of an horizontal mouse motion. Depends on the
|
||||
// Inverse the direction of a horizontal mouse motion. Depends on the
|
||||
// projected screen orientation of the vertical axis when the mouse button is
|
||||
// pressed.
|
||||
bool constrainedRotationIsReversed_;
|
||||
|
|
|
|||
|
|
@ -743,7 +743,7 @@ public:
|
|||
typedef std::vector<Halfedge_handle> HVector;
|
||||
HVector stack;
|
||||
// Algorithm: The next() pointer is used as visited tag
|
||||
// for a graph search. If the next pointer of an halfedge
|
||||
// for a graph search. If the next pointer of a halfedge
|
||||
// or its opposite halfedge is set to Halfedge_handle(),
|
||||
// this edge has already been visited and must not be put
|
||||
// on the stack again.
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ The Delaunay triangulation of a set of points \f$P\f$ in the hyperbolic plane \f
|
|||
|
||||
- `HyperbolicDelaunayTriangulationTraits_2` describes the requirements for an interface for geometric objects, constructions, and predicates in the hyperbolic plane.
|
||||
- `HyperbolicTriangulationFaceBase_2` describes the requirements for faces of the hyperbolic Delaunay triangulation.
|
||||
- `HyperbolicFaceData` describes the requirements for an hyperbolic marker of faces of the hyperbolic Delaunay triangulation, used to filter faces of the Euclidean Delaunay triangulation.
|
||||
- `HyperbolicFaceData` describes the requirements for a hyperbolic marker of faces of the hyperbolic Delaunay triangulation, used to filter faces of the Euclidean Delaunay triangulation.
|
||||
|
||||
\cgalCRPSection{Classes}
|
||||
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ class. In this example we use the class `Interval_skip_list_interval`.
|
|||
\subsection Interval_skip_listExamplewithFacesofaTriangulated Example with Faces of a Triangulated Terrain
|
||||
|
||||
The second example creates an interval skip list that allows to find all the faces
|
||||
of a terrain intersected by an horizontal plane at a given height.
|
||||
of a terrain intersected by a horizontal plane at a given height.
|
||||
The data points for the terrain are read from a file.
|
||||
|
||||
As model for the interval concept, we use a class that is a wrapper
|
||||
|
|
|
|||
|
|
@ -281,7 +281,7 @@ The following example shows the incremental builder.
|
|||
|
||||
\subsection Linear_cell_complexInsert Insert an Edge Between Two Different Faces
|
||||
|
||||
The following example shows the use of \link GenericMap::insert_cell_1_between_two_cells_2 `insert_cell_1_between_two_cells_2`\endlink operation that inserts an edge between two different faces, thus creating an hole in the first face.
|
||||
The following example shows the use of \link GenericMap::insert_cell_1_between_two_cells_2 `insert_cell_1_between_two_cells_2`\endlink operation that inserts an edge between two different faces, thus creating a hole in the first face.
|
||||
|
||||
\cgalExample{Linear_cell_complex/linear_cell_complex_3_insert.cpp}
|
||||
|
||||
|
|
|
|||
|
|
@ -214,14 +214,14 @@ namespace CGAL {
|
|||
}
|
||||
|
||||
/** Create a vertex attribute.
|
||||
* @return an handle on the new attribute.
|
||||
* @return a handle on the new attribute.
|
||||
*/
|
||||
template<typename ...Args>
|
||||
Vertex_attribute_descriptor create_vertex_attribute(const Args&... args)
|
||||
{ return Base::template create_attribute<0>(args...); }
|
||||
|
||||
/**
|
||||
* Create a new dart associated with an handle through an attribute.
|
||||
* Create a new dart associated with a handle through an attribute.
|
||||
* @param ahandle the point handle to associated with the dart.
|
||||
* @return a Dart_descriptor on the new dart.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -157,7 +157,7 @@ namespace CGAL {
|
|||
return is;
|
||||
}
|
||||
|
||||
/** Import the given hds which should be a model of an halfedge graph. */
|
||||
/** Import the given hds which should be a model of a halfedge graph. */
|
||||
template<class HEG, class PointConverter>
|
||||
void import_from_halfedge_graph(const HEG& heg ,
|
||||
const PointConverter& pointconverter,
|
||||
|
|
@ -198,7 +198,7 @@ namespace CGAL {
|
|||
}
|
||||
}
|
||||
|
||||
/** Import the given hds which should be a model of an halfedge graph. */
|
||||
/** Import the given hds which should be a model of a halfedge graph. */
|
||||
template<class HEG>
|
||||
void import_from_halfedge_graph(const HEG& heg,
|
||||
std::unordered_map
|
||||
|
|
|
|||
|
|
@ -977,7 +977,7 @@ bool test_LCC_3()
|
|||
lcc.template sew<3>(dh3, lcc.make_combinatorial_polygon(4));
|
||||
create_attributes_3(lcc);
|
||||
|
||||
// Create an hole in the face between the two cubes
|
||||
// Create a hole in the face between the two cubes
|
||||
lcc.insert_cell_1_between_two_cells_2(lcc.template opposite<2>(lcc.next(lcc.next(dh1))),
|
||||
lcc.next(lcc.next(dh3)));
|
||||
|
||||
|
|
|
|||
|
|
@ -78,7 +78,7 @@ halfedge data structure than by using the high-level Euler operators
|
|||
of the polyhedron.
|
||||
|
||||
\cgalFigureBegin{figureModifierDesign,modifier_small.png}
|
||||
Class diagram for the modifier. It illustrates the safe access to an internal representation through an high-level interface.
|
||||
Class diagram for the modifier. It illustrates the safe access to an internal representation through a high-level interface.
|
||||
\cgalFigureEnd
|
||||
|
||||
The solution provided here is inspired by the strategy
|
||||
|
|
|
|||
|
|
@ -2071,7 +2071,7 @@ public:
|
|||
std::cout << "\n";
|
||||
#endif
|
||||
|
||||
//backup an halfedge per polyline
|
||||
//backup a halfedge per polyline
|
||||
std::vector <halfedge_descriptor> tm1_polylines, tm2_polylines;
|
||||
std::vector<std::size_t> polyline_lengths;
|
||||
|
||||
|
|
|
|||
|
|
@ -1309,7 +1309,7 @@ public:
|
|||
// cut the polyhedron into two parts along the cycle (h,i,j).
|
||||
// Three copies of the vertices and two new triangles will be
|
||||
// created. h,i,j will be incident to the first new triangle. The
|
||||
// returnvalue will be an halfedge iterator denoting the new
|
||||
// returnvalue will be a halfedge iterator denoting the new
|
||||
// halfedges of the second new triangle which was h beforehand.
|
||||
// Precondition: h,i,j are distinct, consecutive vertices of the
|
||||
// polyhedron and form a cycle: i.e. `h->vertex() == i->opposite()
|
||||
|
|
@ -1360,7 +1360,7 @@ public:
|
|||
|
||||
Halfedge_handle join_loop( Halfedge_handle h, Halfedge_handle g) {
|
||||
// glues the boundary of two facets together. Both facets and the
|
||||
// vertices of g gets removed. Returns an halfedge iterator for h.
|
||||
// vertices of g gets removed. Returns a halfedge iterator for h.
|
||||
// The invariant `join_loop( h, split_loop( h, i, j))' returns h
|
||||
// and keeps the polyhedron unchanged. Precondition: `HDS'
|
||||
// supports removal of vertices and facets. The facets denoted by
|
||||
|
|
@ -1591,7 +1591,7 @@ public:
|
|||
<< std::endl;
|
||||
break;
|
||||
}
|
||||
// Distinct facets on each side of an halfedge.
|
||||
// Distinct facets on each side of a halfedge.
|
||||
valid = valid && ( ! check_tag( Supports_halfedge_face()) ||
|
||||
D.get_face(i) != D.get_face(i->opposite()));
|
||||
if ( ! valid) {
|
||||
|
|
|
|||
|
|
@ -384,7 +384,7 @@ protected:
|
|||
|
||||
Halfedge_handle lookup_halfedge( size_type w, size_type v) {
|
||||
// Pre: 0 <= w,v < new_vertices
|
||||
// Case a: It exists an halfedge g from w to v:
|
||||
// Case a: It exists a halfedge g from w to v:
|
||||
// g must be a border halfedge and the facet of g->opposite()
|
||||
// must be set and different from the current facet.
|
||||
// Set the facet of g to the current facet. Return the
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@
|
|||
* depth 0,1,2+ where depth is the number of inserted open half-circles inserted
|
||||
* that covers this cell in addition this class contains some static functions
|
||||
* that are in this class inorder of sharing its typedefs all the circle is
|
||||
* always covered by some cell. there can't be an hole
|
||||
* always covered by some cell. there can't be a hole
|
||||
*/
|
||||
|
||||
namespace CGAL {
|
||||
|
|
|
|||
|
|
@ -2104,7 +2104,7 @@ void Straight_skeleton_builder_2<Gt,Ss,V>::EnforceSimpleConnectedness()
|
|||
// For each face with hole(s), create the extra halfedges to bridge the gap between
|
||||
// the skeleton face's border and the holes by shooting a ray from a vertex hole to a halfedge
|
||||
// .first is the source of the ray
|
||||
// .second is th event creating the intersection of the ray with an halfedge
|
||||
// .second is th event creating the intersection of the ray with a halfedge
|
||||
|
||||
// Collect first for all faces, apply later because one might split
|
||||
std::vector<std::pair<Halfedge_handle, EventPtr> > artifical_events;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ namespace Surface_mesh_topology {
|
|||
/*!
|
||||
\ingroup PkgSurfaceMeshTopologyClasses
|
||||
|
||||
The class `Curves_on_surface_topology` provides methods to compute shortest non contractible cycles and to test homotopy on paths. Each object of this class is constructed from an external mesh, either a \ref CombinatorialMap "2D combinatorial map" or a model of a FaceGraph. It maintains a correspondence between this mesh and an internal representation, computed the first time an homotopy test is called. The user must not modify the input surface as long as homotopy tests are performed with this `Curves_on_surface_topology`.
|
||||
The class `Curves_on_surface_topology` provides methods to compute shortest non contractible cycles and to test homotopy on paths. Each object of this class is constructed from an external mesh, either a \ref CombinatorialMap "2D combinatorial map" or a model of a FaceGraph. It maintains a correspondence between this mesh and an internal representation, computed the first time a homotopy test is called. The user must not modify the input surface as long as homotopy tests are performed with this `Curves_on_surface_topology`.
|
||||
|
||||
\tparam Mesh a model of `CombinatorialMap` or of `FaceGraph`
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -59,7 +59,7 @@ The algorithm used is based on a paper by Despré and Lazarus \cgalCite{cgal:dl-
|
|||
|
||||
\subsection SMTopology_Input Specifying the Input Surface and Curves
|
||||
|
||||
The main class for this package is `Surface_mesh_topology::Curves_on_surface_topology`. Its constructor takes the input surface. An internal representation of the surface (described below) is computed the first time an homotopy test is called.
|
||||
The main class for this package is `Surface_mesh_topology::Curves_on_surface_topology`. Its constructor takes the input surface. An internal representation of the surface (described below) is computed the first time a homotopy test is called.
|
||||
|
||||
Each combinatorial curve on this surface is contained in an instance of the class `Surface_mesh_topology::Path_on_surface`. An object in this class behaves as a list. This list is initially empty and the halfedges corresponding to the sequence of consecutive oriented edges of an input curve should be pushed back in this list. The class provides four ways for extending a nonempty path.
|
||||
- Simply push the next halfedge using the \ref Surface_mesh_topology::Path_on_surface::push_back "push_back()" member function. One can also specify if this halfedge should have its direction flipped so as to satisfy the condition of a `Path_on_surface` (see the description of \ref Surface_mesh_topology::Path_on_surface::can_be_pushed "can_be_pushed()" below) This can be done even when the path is empty,
|
||||
|
|
@ -121,7 +121,7 @@ Given two `Surface_mesh_topology::Path_on_surface` \f$p_1\f$ and \f$p_2\f$, the
|
|||
|
||||
- \ref Surface_mesh_topology::Curves_on_surface_topology::are_homotopic_with_fixed_endpoints "are_homotopic_with_fixed_endpoints"(\f$p_1\f$, \f$p_2\f$) returns `true` if the paths \f$p_1\f$ and \f$p_2\f$ are homotopic with fixed endpoints. This call is equivalent to \ref Surface_mesh_topology::Curves_on_surface_topology::is_contractible "is_contractible"(\f$p_1\cdot \overline{p_2}\f$), where \f$p_1\cdot \overline{p_2}\f$ is the concatenation of \f$p_1\f$ and the reverse of \f$p_2\f$.
|
||||
|
||||
A common first step in the homotopy test algorithms is to simplify the input combinatorial surface. This preprocessing step is done once and for all for a given mesh, the first time an homotopy test is called. The simplified surface is a quadrangulation, every face of which is a quadrilateral, stored in a `Surface_mesh_topology::Curves_on_surface_topology`. It has 2 vertices and \f$2g\f$ quadrilaterals where \f$g\f$ is the genus of
|
||||
A common first step in the homotopy test algorithms is to simplify the input combinatorial surface. This preprocessing step is done once and for all for a given mesh, the first time a homotopy test is called. The simplified surface is a quadrangulation, every face of which is a quadrilateral, stored in a `Surface_mesh_topology::Curves_on_surface_topology`. It has 2 vertices and \f$2g\f$ quadrilaterals where \f$g\f$ is the genus of
|
||||
the input surface. This is otherwise independent of the size of input surface,
|
||||
\note The user must not modify the input surface as long as homotopy tests are performed with this `Surface_mesh_topology::Curves_on_surface_topology`.
|
||||
|
||||
|
|
@ -188,7 +188,7 @@ The machine used is a PC running Ubuntu 18.04 with an Intel CPU Core i7-4790 CPU
|
|||
|
||||
\subsection SMTopology_bench1 Combinatorial Surface Topology Computation Time
|
||||
|
||||
The first time an homotopy test is called, we build a special quadrangulation of the surface as internal representation (as explained in Section \ref SMTopology_Theory "Implementation Details"). The complexity of this operation is linear in the number of darts of the input surface, as we can see in \cgalFigureRef{fig_sm_topology_bench1}.
|
||||
The first time a homotopy test is called, we build a special quadrangulation of the surface as internal representation (as explained in Section \ref SMTopology_Theory "Implementation Details"). The complexity of this operation is linear in the number of darts of the input surface, as we can see in \cgalFigureRef{fig_sm_topology_bench1}.
|
||||
|
||||
For this benchmark, we computed 38 `Surface_mesh_topology::Curves_on_surface_topology` objects for different input surfaces with different number of darts (between 8,000 and 30,000,000). We show in the figure the computation time of the quadrangulation according to the number of darts of the input surface. We remind that this computation needs be done only once if you want to perform several path homotopy tests on the same surface.
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@
|
|||
// Should be defined before to include Path_on_surface_with_rle.h
|
||||
// If nothing is defined, use V1
|
||||
// #define CGAL_PWRLE_TURN_V1 // Compute turns by turning (method of CMap)
|
||||
// #define CGAL_PWRLE_TURN_V2 // Compute turns by using an id of darts, given by an hash-table (built and given by Minimal_quadrangulation)
|
||||
// #define CGAL_PWRLE_TURN_V2 // Compute turns by using an id of darts, given by an hash table (built and given by Minimal_quadrangulation)
|
||||
#define CGAL_PWRLE_TURN_V3 // Compute turns by using an id of darts, associated in Info of Darts (build by Minimal_quadrangulation)
|
||||
|
||||
#include <CGAL/license/Surface_mesh_topology.h>
|
||||
|
|
|
|||
|
|
@ -256,7 +256,7 @@ Constrained_edges constrained_edges() const;
|
|||
|
||||
/*!
|
||||
inserts point `p` and restores the status (constrained or not) of all
|
||||
the touched edges. If present, `f` is used as an hint
|
||||
the touched edges. If present, `f` is used as a hint
|
||||
for the location of `p`.
|
||||
*/
|
||||
Vertex_handle insert(Point p, Face_handle f = Face_handle() );
|
||||
|
|
|
|||
|
|
@ -214,7 +214,7 @@ Regular_triangulation_2 ( InputIterator first, InputIterator last, Traits gt = T
|
|||
inserts weighted point `p` in the regular triangulation.
|
||||
If the point `p` does not appear as a vertex of the triangulation,
|
||||
the returned vertex is a hidden vertex.
|
||||
If given the parameter `f` is used as an hint
|
||||
If given the parameter `f` is used as a hint
|
||||
for the place to start the location process of point `p`.
|
||||
*/
|
||||
Vertex_handle insert(const Weighted_point& p, Face_handle f=Face_handle());
|
||||
|
|
|
|||
Loading…
Reference in New Issue