diff --git a/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Combinatorial_map_2_incremental_builder.h b/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Combinatorial_map_2_incremental_builder.h index 61698ab08b7..c21003464a0 100644 --- a/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Combinatorial_map_2_incremental_builder.h +++ b/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Combinatorial_map_2_incremental_builder.h @@ -14,52 +14,49 @@ namespace CGAL { /// Dart_handle type. typedef typename CMap::Dart_handle Dart_handle; - /*! Constructor. Creates a Combinatorial_map_2_incremental_builder object, to create amap. + /*! creates a `Combinatorial_map_2_incremental_builder` object, to create amap. */ Combinatorial_map_2_incremental_builder(CMap& amap); - /// Start a new surface + /// starts a new surface void begin_surface(); - /// End of the surface. Return one dart of the created surface. + /// finishs the current surface. Returns one dart of the created surface. /// @pre A surface is under creation. Dart_handle end_surface(); - /// Start a new facet. + /// starts a new facet. void begin_facet(); - /// End of the facet. Return the first dart of this facet. + /// finishs the current facet. Returns the first dart of this facet. /// @pre A facet is under creation. Dart_handle end_facet(); - /// Add one edge to the current facet, given by its label (any string, using minus sign for orientation) + /// adds one edge to the current facet, given by its label `s` (any string, using minus sign for orientation) /// @pre A facet is under creation. void add_edge_to_facet(const std::string& s); - /// Add the given edges to the current facet - /// s is a sequence of labels, add all the corresponding edges into the current facet. + /// adds the given edges to the current facet. + /// `s` is a sequence of labels, add all the corresponding edges into the current facet. /// @pre A facet is under creation. void add_edges_to_facet(const std::string& s); - /// Add directly one facet giving the sequence of labels 's' of all its edges. + /// adds directly one facet giving the sequence of labels `s` of all its edges. /// @pre A surface is under creation. void add_facet(const std::string& s); - /// Start a path on the surface + /// starts a path on the surface. void begin_path(); - /// End the current path. - /// @return The path created. + /// finishs the current path. Returns the path created. /// @pre A path is under creation. CGAL::Path_on_surface end_path(); - /// Add edge labeled e at the end of the current path + /// adds edge labeled `e` at the end of the current path. /// @pre A path is under creation. void add_edge_to_path(const std::string& e); - /// A shortcut enabling to create a path directly with a sequence of edge labels - /// @return The path created. + /// create a path directly from a sequence of edge labels `s`. Returns the path created. CGAL::Path_on_surface create_path(const std::string& s); - }; } diff --git a/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Path_on_surface.h b/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Path_on_surface.h index aab3a813129..d2d3adc074b 100644 --- a/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Path_on_surface.h +++ b/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Path_on_surface.h @@ -3,7 +3,7 @@ namespace CGAL { /*! \ingroup PkgSurfaceMeshTopologyClasses - The class `Path_on_surface` represents a walk in a mesh which is either a 2D `CombinatorialMap` or a model of a `FaceGraph`. Each object in this class is constructed from an external mesh on which the path should lie. A path is represented as a sequence of darts or half-edges, each one representing an oriented edge in the path. The class `Path_on_surface` behaves as a container for this sequence of darts/half-edges. Elements are added in the path one at a time to the path thanks to the `push_back()` method. + The class `Path_on_surface` represents a walk in a mesh which is either a 2D `CombinatorialMap` or a model of a `FaceGraph`. Each object of this class is constructed from an external mesh on which the path should lie. A path is represented as a sequence of darts or halfedges, each one representing an oriented edge in the path. The class `Path_on_surface` behaves as a container for this sequence of darts/halfedges. Elements are added in the path one at a time to the path thanks to the `push_back()` method. \tparam Mesh a model of `CombinatorialMap` or of `FaceGraph` */ @@ -12,60 +12,59 @@ namespace CGAL { { public: /*! - %Dart const handle type. An handle to Dart for combinatorial maps, or an half-edge descriptor for models of FaceGraph. + %halfedge_descriptor type. A handle to Dart for combinatorial maps, or a halfedge descriptor for models of FaceGraph. */ - typedef unspecified_type Dart_const_handle; + typedef unspecified_type halfedge_descriptor; - /// Constructor. Creates an empty path object which lies on amesh. + /// creates an empty path object which lies on `amesh`. Path_on_surface(const Mesh& amesh); - /// @return `true` iff the path is empty + /// returns `true` iff this path is empty bool is_empty() const; - /// @return `true` iff the path is closed. + /// returns `true` iff this path is closed. bool is_closed() const; - /// @return `true` iff the path does not pass twice through a same edge - /// or a same vertex. + /// returns `true` iff this path does not pass twice through a same edge or a same vertex. bool is_simple() const; - /// clear the path. + /// clears this path. void clear(); - /// @return `true` iff dh can be added at the end of the path. - bool can_be_pushed(Dart_const_handle dh) const; + /// returns `true` iff `hd` can be added at the end of this path. + bool can_be_pushed(halfedge_descriptor hd) const; - /// Add the given dart/half-edge at the end of this path. - /// @pre can_be_pushed(dh) - void push_back(Dart_const_handle dh); + /// adds `hd` at the end of this path. + /// @pre `can_be_pushed(hd)` + void push_back(halfedge_descriptor hd); - /// Add the dart/half-edge with given index i at the end of this path. - /// @pre can_be_pushed_by_index(i) + /// adds the dart/halfedge with index `i` at the end of this path. + /// @pre `can_be_pushed_by_index(i)` void push_back_by_index(std::size_t i); - /// @return `true` iff the dart/half-edge with index i can be added at the end of the path. + /// returns `true` iff the dart/halfedge with index `i` can be added at the end of this path. bool can_be_pushed_by_index(std::size_t i) const; - /// Add the dart/half-edge obtained by turning nb times around the target vertex of the last dart/half-edge in this path, in the positive circular order. - /// @pre !is_empty() + /// Add the dart/halfedge obtained by turning `nb` times around the target vertex of the last dart/halfedge in this path, in the positive circular order. + /// @pre !`is_empty()` void extend_positive_turn(std::size_t nb); - /// Add the dart/half-edge obtained by turning nb times around the target vertex of the last dart/half-edge in this path, in the negative circular order. - /// @pre !is_empty() + /// Add the dart/halfedge obtained by turning `nb` times around the target vertex of the last dart/halfedge in this path, in the negative circular order. + /// @pre !`is_empty()` void extend_negative_turn(std::size_t nb); - /// Concatenation operator. Concatenates other to this path. - /// @pre the last vertex of this path should coincide with the first vertex of other. + /// concatenates `other` to this path. + /// @pre the last vertex of this path should coincide with the first vertex of `other`. Self& operator+=(const Self& other); - /// Reverse the path (i.e. negate its orientation). + /// reverses this path (i.e. negate its orientation). void reverse(); - /// Creates a random open path with lenght darts/half-edges. - void generate_random_path(std::size_t lenght, CGAL::Random& random=CGAL::get_default_random()); + /// creates a random open path with lenght darts/halfedges. + void generate_random_path(std::size_t lenght, Random& random=get_default_random()); - /// Creates a random closed path with at least lenght darts/half-edges. - void generate_random_closed_path(std::size_t length, CGAL::Random& random=CGAL::get_default_random()); + /// creates a random closed path with at least lenght darts/halfedges. + void generate_random_closed_path(std::size_t length, Random& random=get_default_random()); }; } diff --git a/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Surface_mesh_curve_topology.h b/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Surface_mesh_curve_topology.h index 1b1fa182832..5a5e5f3b438 100644 --- a/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Surface_mesh_curve_topology.h +++ b/Surface_mesh_topology/doc/Surface_mesh_topology/CGAL/Surface_mesh_curve_topology.h @@ -3,7 +3,7 @@ namespace CGAL { /*! \ingroup PkgSurfaceMeshTopologyClasses - The class `Surface_mesh_curve_topology` represents a combinatorial map internally represented as a quadrangulation. Each object in this class is constructed from an external mesh, either a 2D combinatorial map or a model of a FaceGraph. It maintains a correspondence between this mesh and its internal quadrangulation. + The class `Surface_mesh_curve_topology` provides methods to test homotopy on paths. Each object of this class is constructed from an external mesh, either a 2D combinatorial map or a model of a FaceGraph. It maintains a correspondence between this mesh and an internal representation. \tparam Mesh a model of `CombinatorialMap` or of `FaceGraph` */ @@ -12,24 +12,24 @@ namespace CGAL { { public: - /*! Constructor. Creates a Surface_mesh_curve_topology object using amesh as input. + /*! Creates a `Surface_mesh_curve_topology` object using `amesh` as input. */ Surface_mesh_curve_topology(const Mesh& amesh); - /*! Returns `true` if the closed paths p1 and p2 are freely homotopic. - * @pre p1 and p2 must be two paths on amesh. + /*! returns `true` if the closed paths `p1` and `p2` are freely homotopic. + * @pre `p1` and `p2` must be two paths on `amesh`. */ bool are_freely_homotopic(const Path_on_surface& p1, const Path_on_surface& p2) const; - /*! Returns `true` if the paths p1 and p2 are homotopic with fixed endpoints. The paths p1 and p2 must have the same endpoints but must not be closed. Equivalent to `Surface_mesh_curve_topology::is_contractible` (q) where q is the concatenation of p1 and the reverse of p2. - * @pre p1 and p2 must be two paths on amesh. + /*! returns `true` if the paths `p1` and `p2` are homotopic with fixed endpoints. The paths `p1` and `p2` must have the same endpoints but must not be closed. Equivalent to `Surface_mesh_curve_topology::is_contractible(q)` where `q` is the concatenation of `p1` and the reverse of `p2`. + * @pre `p1` and `p2` must be two paths on `amesh`. */ bool are_base_point_homotopic(const Path_on_surface& p1, const Path_on_surface& p2) const; - /*! Returns `true` if the closed path p is contractible. - * @pre p must be two paths on amesh. + /*! returns `true` if the closed path `p` is contractible. + * @pre `p` must be a closed path on `amesh`. */ bool is_contractible(const Path_on_surface& p) const; };