From f3924fe8d68cbc0765067342c2a6ee5ebf20e57d Mon Sep 17 00:00:00 2001 From: Laurent Rineau Date: Fri, 1 Sep 2017 17:36:32 +0200 Subject: [PATCH] curve segment -> curve --- .../Mesh_3/CGAL/Compact_mesh_cell_base_3.h | 2 +- Mesh_3/doc/Mesh_3/CGAL/Mesh_cell_base_3.h | 2 +- .../CGAL/Mesh_complex_3_in_triangulation_3.h | 10 +- Mesh_3/doc/Mesh_3/CGAL/Mesh_criteria_3.h | 2 +- .../Mesh_domain_with_polyline_features_3.h | 4 +- Mesh_3/doc/Mesh_3/CGAL/Mesh_edge_criteria_3.h | 2 +- Mesh_3/doc/Mesh_3/CGAL/Mesh_facet_topology.h | 6 +- Mesh_3/doc/Mesh_3/CGAL/Mesh_triangulation_3.h | 2 +- Mesh_3/doc/Mesh_3/CGAL/Mesh_vertex_base_3.h | 2 +- Mesh_3/doc/Mesh_3/CGAL/make_mesh_3.h | 2 +- Mesh_3/doc/Mesh_3/CGAL/refine_mesh_3.h | 4 +- ...shComplexWithFeatures_3InTriangulation_3.h | 56 ++--- .../Concepts/MeshComplex_3InTriangulation_3.h | 2 +- .../Concepts/MeshDomainWithFeatures_3.h | 107 ++++---- Mesh_3/doc/Mesh_3/Mesh_3.txt | 16 +- Mesh_3/doc/Mesh_3/PackageDescription.txt | 2 +- .../Mesh_3/mesh_polyhedral_complex.cpp | 2 +- .../mesh_polyhedral_domain_with_features.cpp | 2 +- ...olyhedral_domain_with_lipschitz_sizing.cpp | 2 +- ..._polyhedral_domain_with_surface_inside.cpp | 2 +- .../mesh_two_implicit_spheres_with_balls.cpp | 2 +- .../Mesh_3/remesh_polyhedral_surface.cpp | 2 +- .../CGAL/Mesh_3/Protect_edges_sizing_field.h | 153 ++++++------ ...cet_topological_criterion_with_adjacency.h | 2 +- .../Lipschitz_sizing_experimental.h | 2 +- .../Sizing_field_with_aabb_tree.h | 4 +- .../CGAL/Mesh_complex_3_in_triangulation_3.h | 78 +++--- .../Mesh_domain_with_polyline_features_3.h | 230 +++++++++--------- .../CGAL/Polyhedral_complex_mesh_domain_3.h | 4 +- .../Polyhedral_mesh_domain_with_features_3.h | 8 +- .../include/CGAL/internal/Mesh_3/get_index.h | 4 +- Mesh_3/test/Mesh_3/test_c3t3_io.cpp | 26 +- .../test/Mesh_3/test_c3t3_with_features.cpp | 42 ++-- .../test_domain_with_polyline_features.cpp | 40 +-- Mesh_3/test/Mesh_3/test_mesh_3_issue_1554.cpp | 2 +- .../test/Mesh_3/test_meshing_determinism.cpp | 2 +- .../test_meshing_polyhedral_complex.cpp | 2 +- .../test_meshing_polyhedron_with_features.cpp | 2 +- .../Mesh_3/test_meshing_polylines_only.cpp | 2 +- .../Mesh_3/test_meshing_unit_tetrahedron.cpp | 2 +- 40 files changed, 425 insertions(+), 413 deletions(-) diff --git a/Mesh_3/doc/Mesh_3/CGAL/Compact_mesh_cell_base_3.h b/Mesh_3/doc/Mesh_3/CGAL/Compact_mesh_cell_base_3.h index 575e81452f9..a639c1fc3c7 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/Compact_mesh_cell_base_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/Compact_mesh_cell_base_3.h @@ -22,7 +22,7 @@ default parameter value `void`. \cgalModels `MeshCellBase_3` -\sa `CGAL::Mesh_complex_3_in_triangulation_3` +\sa `CGAL::Mesh_complex_3_in_triangulation_3` \sa `CGAL::Mesh_cell_base_3` */ diff --git a/Mesh_3/doc/Mesh_3/CGAL/Mesh_cell_base_3.h b/Mesh_3/doc/Mesh_3/CGAL/Mesh_cell_base_3.h index 1575223d944..7be5288abec 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/Mesh_cell_base_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/Mesh_cell_base_3.h @@ -28,7 +28,7 @@ of the concept `RegularTriangulationCellBaseWithWeightedCircumcenter_3` and defa \cgalModels `MeshCellBase_3` -\sa `CGAL::Mesh_complex_3_in_triangulation_3` +\sa `CGAL::Mesh_complex_3_in_triangulation_3` \sa `CGAL::Compact_mesh_cell_base_3` */ diff --git a/Mesh_3/doc/Mesh_3/CGAL/Mesh_complex_3_in_triangulation_3.h b/Mesh_3/doc/Mesh_3/CGAL/Mesh_complex_3_in_triangulation_3.h index 87807079728..168c0566e86 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/Mesh_complex_3_in_triangulation_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/Mesh_complex_3_in_triangulation_3.h @@ -19,8 +19,8 @@ vertex and cell base class are models of the concepts \tparam CornerIndex is the type of the indices for corners. It must match the `Corner_index` of the model of the `MeshDomainWithFeatures_3` concept used for mesh generation. -\tparam CurveSegmentIndex is the type of the indices for curves segments. -It must match the `Curve_segment_index` types of the model +\tparam CurveIndex is the type of the indices for curves. +It must match the `Curve_index` types of the model of the `MeshDomainWithFeatures_3` concept used for mesh generation. Those two last template parameters defaults to `int`, so that they can be ignored @@ -37,7 +37,7 @@ is a model of the concept `MeshDomain_3`). \sa `MeshVertexBase_3` */ -template< typename Tr, typename CornerIndex, typename CurveSegmentIndex > +template< typename Tr, typename CornerIndex, typename CurveIndex > class Mesh_complex_3_in_triangulation_3 { public: @@ -65,9 +65,9 @@ typedef Tr::Cell::Subdomain_index Subdomain_index; typedef CornerIndex Corner_index; /*! -Curve segment index type. +Curve index type. */ -typedef CurveSegmentIndex Curve_segment_index; +typedef CurveIndex Curve_index; /// @} diff --git a/Mesh_3/doc/Mesh_3/CGAL/Mesh_criteria_3.h b/Mesh_3/doc/Mesh_3/CGAL/Mesh_criteria_3.h index bafa7442629..95356faad31 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/Mesh_criteria_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/Mesh_criteria_3.h @@ -115,7 +115,7 @@ The description of each parameter is as follows: - `edge_size`: a scalar field (resp. a constant) providing a space varying (resp. a uniform) -upper bound for the lengths of curve segment edges. This parameter has to be set to a positive +upper bound for the lengths of curve edges. This parameter has to be set to a positive value when 1-dimensional features protection is used. - `facet_angle`: a lower bound for the angles (in degrees) of the diff --git a/Mesh_3/doc/Mesh_3/CGAL/Mesh_domain_with_polyline_features_3.h b/Mesh_3/doc/Mesh_3/CGAL/Mesh_domain_with_polyline_features_3.h index a596a353b13..a15642524d9 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/Mesh_domain_with_polyline_features_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/Mesh_domain_with_polyline_features_3.h @@ -35,9 +35,9 @@ public: typedef int Corner_index; /*! -`Curve_segment_index` type. +`Curve_index` type. */ -typedef int Curve_segment_index; +typedef int Curve_index; /// @} diff --git a/Mesh_3/doc/Mesh_3/CGAL/Mesh_edge_criteria_3.h b/Mesh_3/doc/Mesh_3/CGAL/Mesh_edge_criteria_3.h index be93ff57939..93beddc81d2 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/Mesh_edge_criteria_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/Mesh_edge_criteria_3.h @@ -33,7 +33,7 @@ typedef Tr::Geom_traits::FT FT; /*! Returns an object to serve as criteria for edges. The argument `length_bound` is an upper bound -for the length of the edges which are used to discretize the curve segments. +for the length of the edges which are used to discretize the curves. Note that if one parameter is set to 0, then its corresponding criteria is ignored. */ Mesh_edge_criteria_3( diff --git a/Mesh_3/doc/Mesh_3/CGAL/Mesh_facet_topology.h b/Mesh_3/doc/Mesh_3/CGAL/Mesh_facet_topology.h index 6fdb737bb23..3f331ec9b0c 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/Mesh_facet_topology.h +++ b/Mesh_3/doc/Mesh_3/CGAL/Mesh_facet_topology.h @@ -11,13 +11,13 @@ be checked on each surface facet during the mesh refinement process. */ enum Mesh_facet_topology { FACET_VERTICES_ON_SURFACE = 1, //!< Each vertex of the facet have - //!< to be on the surface, on a curve segment, or on a corner. + //!< to be on the surface, on a curve, or on a corner. FACET_VERTICES_ON_SAME_SURFACE_PATCH, //!< The three vertices of a facet belonging //!< to a surface patch `s` have to be on - //!< the same surface patch `s`, on a curve segment or on a corner. + //!< the same surface patch `s`, on a curve or on a corner. /*! The three vertices of a facet belonging to a surface patch `s` - have to be on the same surface patch `s`, or on a curve segment + have to be on the same surface patch `s`, or on a curve incident to the surface patch `s` or on a corner incident to the surface patch `s`. */ diff --git a/Mesh_3/doc/Mesh_3/CGAL/Mesh_triangulation_3.h b/Mesh_3/doc/Mesh_3/CGAL/Mesh_triangulation_3.h index 4b9b869b345..1caebccb38b 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/Mesh_triangulation_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/Mesh_triangulation_3.h @@ -32,7 +32,7 @@ and defaults to `Compact_mesh_cell_base_3`. will have type `Robust_weighted_circumcenter_filtered_traits_3`. \sa `make_mesh_3()` -\sa `Mesh_complex_3_in_triangulation_3` +\sa `Mesh_complex_3_in_triangulation_3` */ template< typename MD, typename Gt, diff --git a/Mesh_3/doc/Mesh_3/CGAL/Mesh_vertex_base_3.h b/Mesh_3/doc/Mesh_3/CGAL/Mesh_vertex_base_3.h index 6ded064b743..3a6275ed6bf 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/Mesh_vertex_base_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/Mesh_vertex_base_3.h @@ -21,7 +21,7 @@ of the concept `TriangulationVertexBase_3` and defaults to \cgalModels `MeshVertexBase_3` -\sa `CGAL::Mesh_complex_3_in_triangulation_3` +\sa `CGAL::Mesh_complex_3_in_triangulation_3` */ template< typename Gt, typename MD, typename Vb > diff --git a/Mesh_3/doc/Mesh_3/CGAL/make_mesh_3.h b/Mesh_3/doc/Mesh_3/CGAL/make_mesh_3.h index 9a350b2972e..5c782dccc62 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/make_mesh_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/make_mesh_3.h @@ -43,7 +43,7 @@ respectively. \tparam MeshDomain_3 is required to be a model of the concept `MeshDomain_3`, or of the refined concept `MeshDomainWithFeatures_3` -if the domain has corners and curve segments that need to be accurately represented in the mesh. +if the domain has corners and curves that need to be accurately represented in the mesh. The argument `domain` is the sole link through which the domain to be discretized is known by the mesh generation algorithm. diff --git a/Mesh_3/doc/Mesh_3/CGAL/refine_mesh_3.h b/Mesh_3/doc/Mesh_3/CGAL/refine_mesh_3.h index 05d32314ea4..be5a20640a1 100644 --- a/Mesh_3/doc/Mesh_3/CGAL/refine_mesh_3.h +++ b/Mesh_3/doc/Mesh_3/CGAL/refine_mesh_3.h @@ -198,7 +198,7 @@ parameters::internal::Exude_options exude( The function `parameters::features()` provides a value of internal type `Features` to specify if 0 and 1-dimensional features have to be taken into account. The provided value is a default value that triggers the representation -of corners and curve segments in the mesh when the domain is a model +of corners and curves in the mesh when the domain is a model of `MeshDomainWithFeatures_3`. Provides a `Features_options` value such that @@ -284,7 +284,7 @@ parameters::internal::Exude_options no_exude(); The function `parameters::no_features()` allows the user to prevent the handling of 0 and 1-dimensional features. This is useful when the domain is a model of `MeshDomainWithFeatures_3` -and the user does not want corners and curve segments +and the user does not want corners and curves to be accurately represented in the mesh. diff --git a/Mesh_3/doc/Mesh_3/Concepts/MeshComplexWithFeatures_3InTriangulation_3.h b/Mesh_3/doc/Mesh_3/Concepts/MeshComplexWithFeatures_3InTriangulation_3.h index 0fcbb496951..716f6acda16 100644 --- a/Mesh_3/doc/Mesh_3/Concepts/MeshComplexWithFeatures_3InTriangulation_3.h +++ b/Mesh_3/doc/Mesh_3/Concepts/MeshComplexWithFeatures_3InTriangulation_3.h @@ -16,7 +16,7 @@ faces of the triangulation, we call respectively subdomains, surface patches -curve segments and corners the faces +curves and corners the faces of the complex with respective dimensions \f$ 3\f$, \f$ 2\f$, \f$ 1\f$ and \f$ 0\f$. The triangulations faces are called respectively cells, facets, edges and vertices. @@ -24,9 +24,9 @@ cells, facets, edges and vertices. Each subdomain of the embedded 3D complex is a union of triangulation cells. Likewise, each surface patch is a union of -triangulation facets and each curve segment is a union of triangulation edges. +triangulation facets and each curve is a union of triangulation edges. The corners form a subset of the triangulation vertices. -Note that subdomains, surface patches and and curved segments are not +Note that subdomains, and surface patches are not necessarily connected. Likewise each corner may be related to several mesh vertices. Triangulation facets that belong to some @@ -35,7 +35,7 @@ surface patch are called surface facets. The concept `MeshComplexWithFeatures_3InTriangulation_3` allows us to mark and retrieve the cells of the triangulation belonging to the subdomains, the facets of the triangulation belonging to surface patches, -the edges belonging to curve segments and the vertices that are corners of the embedded complex. +the edges belonging to curves and the vertices that are corners of the embedded complex. Within the mesh generation functions, the concept `MeshComplexWithFeatures_3InTriangulation_3` is the concept describing @@ -43,12 +43,12 @@ the data structure used to maintain the current approximation of the input domai At the end of the meshing process, the data structure encodes the resulting mesh. In particular, each subdomain (resp. surface patch) of the input domain is then approximated by a subdomain (resp. a surface patch) of the embedded complex -while the curve segments and corners represent the \f$ 1\f$ and \f$ 0\f$-dimensional features +while the curves and corners represent the \f$ 1\f$ and \f$ 0\f$-dimensional features of the input complex. \cgalRefines `MeshComplex_3InTriangulation_3` -\cgalHasModel `CGAL::Mesh_complex_3_in_triangulation_3` +\cgalHasModel `CGAL::Mesh_complex_3_in_triangulation_3` \sa `MeshComplex_3InTriangulation_3` \sa `MeshDomainWithFeatures_3` @@ -62,11 +62,11 @@ public: /// @{ /*! -A type for indexes of curve segment. The type must match the type -`MeshDomainWithFeatures_3::Curve_segment_index` +A type for indexes of curve. The type must match the type +`MeshDomainWithFeatures_3::Curve_index` when the concept is used for mesh generation. */ -typedef unspecified_type Curve_segment_index; +typedef unspecified_type Curve_index; /*! A type for indexes of corners. @@ -78,9 +78,9 @@ typedef unspecified_type Corner_index; /*! An iterator type to visit the edges -of the triangulation belonging to curve segments. +of the triangulation belonging to curves. */ -typedef unspecified_type Edges_in_complex_iterator; +typedef unspecified_type Edges_in_complex_iterator; /*! An iterator type to visit the vertices @@ -95,16 +95,16 @@ typedef unspecified_type Vertices_in_complex_iterator; /*! -Adds edge `e` as an element of the curve segment with index `index`. +Adds edge `e` as an element of the curve with index `index`. */ -void add_to_complex(Edge e, const Curve_segment_index& index); +void add_to_complex(Edge e, const Curve_index& index); /*! Same as above with `e=(v1,v2)`. */ void add_to_complex(const Vertex_handle& v1, -const Vertex_handle& v2, const Curve_segment_index& index); +const Vertex_handle& v2, const Curve_index& index); /*! @@ -139,15 +139,15 @@ void remove_from_complex(const Vertex_handle& v); /*! -Returns the number of edges which belong to curve segments. +Returns the number of edges which belong to curves. */ size_type number_of_edges() const; /*! -Returns the number of edges which belong to curve segment with index `index`. +Returns the number of edges which belong to curve with index `index`. */ -size_type number_of_edges(Curve_segment_index index) const; +size_type number_of_edges(Curve_index index) const; /*! @@ -163,7 +163,7 @@ size_type number_of_corners(Corner_index index) const; /*! Returns `true` -iff edge `e` belongs to some curve segment. +iff edge `e` belongs to some curve. */ bool is_in_complex(const Edge& e) const; @@ -182,16 +182,16 @@ bool is_in_complex(const Vertex_handle& v) const; /*! -Returns `Curve_segment_index` of edge `e`. The default `Curve_segment_index` -value is returned if edge `e` does not belong to any curve segment. +Returns `Curve_index` of edge `e`. The default `Curve_index` +value is returned if edge `e` does not belong to any curve. */ -Curve_segment_index curve_segment_index(const Edge& e); +Curve_index curve_index(const Edge& e); /*! Same as above with `e=(v1,v2)`. */ -Curve_segment_index curve_segment_index(const Vertex_handle& v1, const Vertex_handle& v2); +Curve_index curve_index(const Vertex_handle& v1, const Vertex_handle& v2); /*! @@ -207,7 +207,7 @@ Corner_index corner_index(const Vertex_handle& v); /*! -Returns an `Edges_in_complex_iterator` to visit the edges of the triangulation belonging to curve segments. +Returns an `Edges_in_complex_iterator` to visit the edges of the triangulation belonging to curves. */ Edges_in_complex_iterator edges_in_complex_begin() const; @@ -219,22 +219,22 @@ Edge_in_complex_iterator edges_in_complex_end() const; /*! -Returns an `Edges_in_complex_iterator` to visit the edges of the triangulation belonging to curve segments +Returns an `Edges_in_complex_iterator` to visit the edges of the triangulation belonging to curves of index `index`. */ -Edges_in_complex_iterator edges_in_complex_begin(Curve_segment_index index) const; +Edges_in_complex_iterator edges_in_complex_begin(Curve_index index) const; /*! Returns the past-the-end iterator for the above iterator. */ -Edge_in_complex_iterator edges_in_complex_end(Curve_segment_index index) const; +Edge_in_complex_iterator edges_in_complex_end(Curve_index index) const; /*! Fills `out` with the vertices of the triangulation that are adjacent to vertex `v` -through an edge belonging to some curve segment. -The value type of `out` must be `std::pair`. +through an edge belonging to some curve. +The value type of `out` must be `std::pair`. \pre `c3t3.in_dimension(v) < 2` */ template diff --git a/Mesh_3/doc/Mesh_3/Concepts/MeshComplex_3InTriangulation_3.h b/Mesh_3/doc/Mesh_3/Concepts/MeshComplex_3InTriangulation_3.h index 5b62a420a20..947fde07aa3 100644 --- a/Mesh_3/doc/Mesh_3/Concepts/MeshComplex_3InTriangulation_3.h +++ b/Mesh_3/doc/Mesh_3/Concepts/MeshComplex_3InTriangulation_3.h @@ -42,7 +42,7 @@ the current approximation of each subdomain and each boundary surface patch. The data structure encodes the final mesh at the end of the meshing process. -\cgalHasModel `CGAL::Mesh_complex_3_in_triangulation_3` +\cgalHasModel `CGAL::Mesh_complex_3_in_triangulation_3` \sa `MeshDomain_3` \sa `MeshComplexWithFeatures_3InTriangulation_3` diff --git a/Mesh_3/doc/Mesh_3/Concepts/MeshDomainWithFeatures_3.h b/Mesh_3/doc/Mesh_3/Concepts/MeshDomainWithFeatures_3.h index 937345b0f55..d448d8c2359 100644 --- a/Mesh_3/doc/Mesh_3/Concepts/MeshDomainWithFeatures_3.h +++ b/Mesh_3/doc/Mesh_3/Concepts/MeshDomainWithFeatures_3.h @@ -7,9 +7,14 @@ While the concept `MeshDomain_3` only exposes the 2-dimensional and 3-dimensional features of the domain through different queries, the concept `MeshDomainWithFeatures_3` also exposes 0 and 1-dimensional features. The exposed features of the domain are respectively called -subdomains, surface patches, curve segments +subdomains, surface patches, curves and corners according to their respective dimensions 3,2,1 and 0. +Each curve is assumed to be bounded, with only one connected component, and +without auto-intersection. Each curve is also assumed to be +oriented. Therefore it is possible to defined the signed geodesic distance +between two ordered points on the same curve. + \cgalRefines `MeshDomain_3` \cgalHasModel `CGAL::Mesh_domain_with_polyline_features_3` @@ -37,13 +42,13 @@ Numerical type. typedef unspecified_type FT; /*! -Type of indices for curve segments (\f$ 1\f$-dimensional features) +Type of indices for curves (\f$ 1\f$-dimensional features) of the input domain. Must be a model of CopyConstructible, Assignable, DefaultConstructible and LessThanComparable. The default constructed value must be the value of an edge which does not approximate a 1-dimensional feature of the input domain. */ -typedef unspecified_type Curve_segment_index; +typedef unspecified_type Curve_index; /*! Type of indices for corners (i.e.\ 0-dimensional features) @@ -56,30 +61,22 @@ typedef unspecified_type Corner_index; /// @} /*! \name Operations -Each connected component of a curve segment is assumed -to be oriented. The orientation is defined by the ordering -of the two incident corners at the origin and endpoint. -Therefore it is possible -to defined the signed geodesic distance between two ordered -points on the same connected component of a curve segment. -A cycle is a connected component of a curve segment incident to -0 or 1 corner. -\note `construct_point_on_curve segment` is assumed to return -a uniquely defined point. Therefore it is not possible to handle as a single -curve segment, a singular curve with several branches incident -to the same point. */ /// @{ /*! -Returns a point on the curve segment with index `ci` +Returns a point on the curve with index `ci` at signed geodesic distance `d` from point `p`. -\pre Point `p` is supposed to be on curve segment `ci`. If ` d > 0`, the signed geodesic distance from `p` to the endpoint of the connected component of `ci` including \f$ p\f$, should be greater than \f$ d\f$. If ` d < 0`, the signed geodesic distance from `p` to the origin of the connected component should be less than \f$ d\f$ from the origin of the connected component. +\pre Point `p` is supposed to be on curve `ci`. If ` d > 0`, the signed +geodesic distance from `p` to the endpoint of `ci` should be greater than +\f$ d\f$. If ` d < 0`, the signed geodesic distance from `p` to the origin +of the curve should be less than \f$ d\f$ from the origin. + */ -Point_3 construct_point_on_curve_segment( -const Point_3& p, const Curve_segment_index& ci, FT d) const; +Point_3 construct_point_on_curve( +const Point_3& p, const Curve_index& ci, FT d) const; /// @} @@ -87,57 +84,55 @@ const Point_3& p, const Curve_segment_index& ci, FT d) const; /// @{ /*! -Returns the length of the curve segment, on the curve with index -\c curve_index, from \c p to \c q +Returns the length of the curve segment from \c p to \c q, on the curve +with index \c curve_index. -If the curve connected component containing \c p and \c q is a cycle, -the orientation identifies which portion of the cycle -corresponds to the arc, otherwise \c orientation must be compatible -with the orientation of \c p and \c q on the curve segment. +If the curve with index \c curve_index is a loop, the +orientation identifies which portion of the loop corresponds to the curve +segment, otherwise \c orientation must be compatible with the orientation +of \c p and \c q on the curve. */ -FT arc_length(const Point_3& p, const Point_3 q, - const Curve_segment_index& curve_index, - CGAL::Orientation orientation) const; +FT curve_segment_length(const Point_3& p, const Point_3 q, + const Curve_index& curve_index, + CGAL::Orientation orientation) const; /*! Returns `CGAL::POSITIVE` if the signed geodesic distance from -`p` to `q` on the way through `r` along cycle with index `ci` +`p` to `q` on the way through `r` along loop with index `ci` is positive, `CGAL::NEGATIVE` if the distance is negative. \pre `p != q && p != r && r != q` */ -CGAL::Sign distance_sign_along_cycle(const Point_3& p, const Point_3& q, -const Point_3& r, const Curve_segment_index& ci) const; +CGAL::Sign distance_sign_along_loop(const Point_3& p, const Point_3& q, +const Point_3& r, const Curve_index& ci) const; /*! Returns the sign of the geodesic distance from `p` to `q`, on the curve with index `ci`. */ CGAL::Sign distance_sign(const Point_3& p, const Point_3& q, - const Curve_segment_index& ci) const; + const Curve_index& ci) const; /*! -Returns the length of the connected component of curve with index -\c curve_index that includes the point \c p +Returns the length of curve with index +\c curve_index */ -FT curve_segment_length(const Point_3& p, - const Curve_segment_index& curve_index) const; +FT curve_length(const Curve_index& curve_index) const; /*! -Returns `true` if the portion of the curve segment of index \c index, +Returns `true` if the portion of the curve of index \c index, between the points \c c1 and \c c2, is covered by the spheres of centers \c c1 and \c c2 and squared radii \c sq_r1 and \c sq_r2 -respectively. The points \c c1 and \c c2 are assumed to lie on the curve -segment. +respectively. The points \c c1 and \c c2 are assumed to lie on the curve. */ -bool is_curve_segment_covered(const Curve_segment_index& index, +bool is_curve_segment_covered(const Curve_index& index, CGAL::Orientation orientation, const Point_3& c1, const Point_3& c2, const FT sq_r1, const FT sq_r2) const; /*! -Returns `true` if the connected component of curve segment -`ci` including point `p` is a cycle. +Returns `true` if the curve +`ci` is a loop. */ -bool is_cycle(const Point_3& p, const Curve_segment_index& ci) const; +bool is_loop(const Curve_index& ci) const; /// @} @@ -154,21 +149,21 @@ get_corners(OutputIterator corners) const; /*! -Fills `curves` with the curve segments +Fills `curves` with the curves of the input domain. `curves` value type must be -`CGAL::cpp11::tuple,std::pair >`. -If the curve segment corresponding to an entry -in curves is not a cycle, the pair of associated points should +`CGAL::cpp11::tuple,std::pair >`. +If the curve corresponding to an entry +in curves is not a loop, the pair of associated points should belong to -two corners incident on the curve segment. -If it is a cycle, then the same `Point_3` should be given twice and must be any -point on the cycle. +two corners incident on the curve. +If it is a loop, then the same `Point_3` should be given twice and must be any +point on the loop. The `%Index` values associated to the points are their indices w.r.t.\ their dimension. */ template OutputIterator -get_curve_segments(OutputIterator curves) const; +get_curves(OutputIterator curves) const; /// @} @@ -177,17 +172,17 @@ get_curve_segments(OutputIterator curves) const; /*! -Returns the index to be stored at a vertex lying on the curve segment identified -by `curve_segment_index`. +Returns the index to be stored at a vertex lying on the curve identified +by `curve_index`. */ -Index index_from_curve_segment_index(const Curve_segment_index& curve_segment_index) const; +Index index_from_curve_index(const Curve_index& curve_index) const; /*! -Returns the `Curve_segment_index` of the curve segment where lies a vertex with +Returns the `Curve_index` of the curve where lies a vertex with dimension 1 and index `index`. */ -Curve_segment_index curve_segment_index(const Index& index) const; +Curve_index curve_index(const Index& index) const; /*! diff --git a/Mesh_3/doc/Mesh_3/Mesh_3.txt b/Mesh_3/doc/Mesh_3/Mesh_3.txt index 01791e76905..d682deb13eb 100644 --- a/Mesh_3/doc/Mesh_3/Mesh_3.txt +++ b/Mesh_3/doc/Mesh_3/Mesh_3.txt @@ -46,7 +46,7 @@ or with respect to some user customized quality criteria. The meshing engine used in this mesh generator is based on Delaunay refinement \cgalCite{c-gqmgc-93}, \cgalCite{r-draq2d-95}, \cgalCite{s-tmgdr-98}. It uses the notion of restricted Delaunay triangulation -to approximate 1-dimensional curve segments and surface patches \cgalCite{cgal:bo-pgsms-05}. +to approximate 1-dimensional curves and surface patches \cgalCite{cgal:bo-pgsms-05}. Before the refinement, a mechanism of protecting balls is set up on 1-dimensional features, if any, to ensure a fair representation of those features in the mesh, and also to guarantee the termination of the refinement process, @@ -77,14 +77,14 @@ some 3D faces may have dangling 2D or 1D faces in their boundary faces. In the rest of the documentation, we will refer to the input 3D complex as the input domain. The faces of the input domain with dimension 0, 1, 2 and 3 are called respectively -corners, curve segments, surface patches and subdomains +corners, curves, surface patches and subdomains to clearly distinguish them from the faces of the mesh that are called vertices, edges, facets and cells. Note that the input complex faces are not required to be linear nor smooth. Surface patches, for instance, may be smooth surface patches, or portions of surface meshes with boundaries. -Curve segments may be for instance straight segments, curved segments +Curves may be for instance straight segments, parameterized curves or polylines. Each of those features will be accurately represented in the final mesh. The 0 and 1-dimensional features of the input domain are usually singular points @@ -102,7 +102,7 @@ in the final mesh. Note also that input complex faces are not required to be connected. Faces of the input domain are identified by indexes. If a subdomain is not connected, its different components receive the same index. -Likewise different surface patches, segment curves or corners may share the same index. +Likewise different surface patches, curves or corners may share the same index. Each connected component of a feature will be accurately represented in the final mesh. Note however that the occurrence of multiply connected faces in the @@ -143,7 +143,7 @@ This \cgal component also provides a function to convert the reconstructed mesh - `facets_in_complex_3_to_triangle_mesh()` The 3D triangulation provides approximations of the -subdomains, surface patches and curve segments +subdomains, surface patches and curves and corners, according to the restricted Delaunay triangulation paradigm. This means that each subdomain is approximated by the union of the tetrahedral cells @@ -376,11 +376,11 @@ the concept `MeshDomainWithFeatures_3` provides the incidence graph of 0, 1 and 2-dimensional features, and a member function to construct -sample points on curve segments. +sample points on curves. Using the parameter of type `Features`, the user whose domain is a model of `MeshDomainWithFeatures_3` -can choose to have the corners and curve segments of the domain +can choose to have the corners and curves of the domain represented in the mesh or not. The type `Features` of this parameter is an internal undescribed type. The library provides functions to construct appropriate values of that type. @@ -428,7 +428,7 @@ provides an upper bound for the distance between the circumcenter of a surface facet and the center of a surface Delaunay ball of this facet.
  • `facet_topology`. This parameters controls the set of topological constraints which have to be verified by each surface facet. By default, each vertex of a surface -facet has to be located on a surface patch, on a curve segment, or on a corner. It can +facet has to be located on a surface patch, on a curve, or on a corner. It can also be set to check whether the three vertices of a surface facet belongs to the same surface patch. This has to be done cautiously, as such a criteria needs that each surface patches intersection is an input 1-dimensional feature. diff --git a/Mesh_3/doc/Mesh_3/PackageDescription.txt b/Mesh_3/doc/Mesh_3/PackageDescription.txt index 681de5a355a..60b787ba111 100644 --- a/Mesh_3/doc/Mesh_3/PackageDescription.txt +++ b/Mesh_3/doc/Mesh_3/PackageDescription.txt @@ -79,7 +79,7 @@ related to the template parameters of some models of the main concepts: ## Classes ## -- `CGAL::Mesh_complex_3_in_triangulation_3` +- `CGAL::Mesh_complex_3_in_triangulation_3` - `CGAL::Mesh_triangulation_3` - `CGAL::Mesh_vertex_base_3` - `CGAL::Compact_mesh_cell_base_3` diff --git a/Mesh_3/examples/Mesh_3/mesh_polyhedral_complex.cpp b/Mesh_3/examples/Mesh_3/mesh_polyhedral_complex.cpp index 8474bed9ff3..3c1b05ec54f 100644 --- a/Mesh_3/examples/Mesh_3/mesh_polyhedral_complex.cpp +++ b/Mesh_3/examples/Mesh_3/mesh_polyhedral_complex.cpp @@ -25,7 +25,7 @@ typedef CGAL::Sequential_tag Concurrency_tag; typedef CGAL::Mesh_triangulation_3::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3< - Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_segment_index> C3t3; + Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_index> C3t3; // Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria; diff --git a/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_features.cpp b/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_features.cpp index 9df6bf26892..05ff6d73f6b 100644 --- a/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_features.cpp +++ b/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_features.cpp @@ -23,7 +23,7 @@ typedef CGAL::Sequential_tag Concurrency_tag; typedef CGAL::Mesh_triangulation_3::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3< - Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_segment_index> C3t3; + Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_index> C3t3; // Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria; diff --git a/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_lipschitz_sizing.cpp b/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_lipschitz_sizing.cpp index 9b3e88c9f7c..fc3e1bf28b4 100644 --- a/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_lipschitz_sizing.cpp +++ b/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_lipschitz_sizing.cpp @@ -26,7 +26,7 @@ typedef CGAL::Sequential_tag Concurrency_tag; // Triangulation typedef CGAL::Mesh_triangulation_3::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3< - Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_segment_index> C3t3; + Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_index> C3t3; // Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria; diff --git a/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_surface_inside.cpp b/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_surface_inside.cpp index 7595d8a9dfd..a559df21506 100644 --- a/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_surface_inside.cpp +++ b/Mesh_3/examples/Mesh_3/mesh_polyhedral_domain_with_surface_inside.cpp @@ -21,7 +21,7 @@ typedef CGAL::Polyhedral_mesh_domain_with_features_3 Mesh_domain; typedef CGAL::Mesh_triangulation_3::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3< - Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_segment_index> C3t3; + Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_index> C3t3; // Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria; diff --git a/Mesh_3/examples/Mesh_3/mesh_two_implicit_spheres_with_balls.cpp b/Mesh_3/examples/Mesh_3/mesh_two_implicit_spheres_with_balls.cpp index 36d914f0d1d..efab3c774bf 100644 --- a/Mesh_3/examples/Mesh_3/mesh_two_implicit_spheres_with_balls.cpp +++ b/Mesh_3/examples/Mesh_3/mesh_two_implicit_spheres_with_balls.cpp @@ -32,7 +32,7 @@ typedef CGAL::Sequential_tag Concurrency_tag; typedef CGAL::Mesh_triangulation_3::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3< - Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_segment_index> C3t3; + Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_index> C3t3; // Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria; diff --git a/Mesh_3/examples/Mesh_3/remesh_polyhedral_surface.cpp b/Mesh_3/examples/Mesh_3/remesh_polyhedral_surface.cpp index 7f52366a2c9..7d87aedbb94 100644 --- a/Mesh_3/examples/Mesh_3/remesh_polyhedral_surface.cpp +++ b/Mesh_3/examples/Mesh_3/remesh_polyhedral_surface.cpp @@ -17,7 +17,7 @@ typedef CGAL::Mesh_polyhedron_3::type Polyhedron; // Triangulation typedef CGAL::Mesh_triangulation_3::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3< - Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_segment_index> C3t3; + Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_index> C3t3; // Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria; diff --git a/Mesh_3/include/CGAL/Mesh_3/Protect_edges_sizing_field.h b/Mesh_3/include/CGAL/Mesh_3/Protect_edges_sizing_field.h index ce3b267a7b5..31175988053 100644 --- a/Mesh_3/include/CGAL/Mesh_3/Protect_edges_sizing_field.h +++ b/Mesh_3/include/CGAL/Mesh_3/Protect_edges_sizing_field.h @@ -124,7 +124,7 @@ public: typedef typename C3T3::Triangulation Triangulation; typedef typename C3T3::Edge Edge; - typedef typename MeshDomain::Curve_segment_index Curve_segment_index; + typedef typename MeshDomain::Curve_index Curve_index; typedef typename MeshDomain::Corner_index Corner_index; typedef typename MeshDomain::Index Index; @@ -141,9 +141,9 @@ public: } private: - typedef std::vector > Incident_edges; - typedef std::vector Vertex_vector; - typedef std::vector > Incident_vertices; + typedef std::vector > Incident_edges; + typedef std::vector Vertex_vector; + typedef std::vector > Incident_vertices; private: /// Insert corners of the mesh @@ -196,7 +196,7 @@ private: template ErasedVeOutIt insert_balls(const Vertex_handle& vp, const Vertex_handle& vq, - const Curve_segment_index& curve_index, + const Curve_index& curve_index, const CGAL::Orientation orientation, ErasedVeOutIt out); @@ -213,7 +213,7 @@ private: const FT size_q, const FT pq_length, const CGAL::Orientation orientation, - const Curve_segment_index& curve_index, + const Curve_index& curve_index, ErasedVeOutIt out); /// Returns `true` if balls of \c va and \c vb intersect, and (va,vb) is not @@ -234,10 +234,10 @@ private: /// \param orientation Orientation of the curve segment between \c v1 and /// \c v2, given the orientation of the curve of index /// \c curve_index - /// \pre `c3t3.curve_segment_index(v1, v2) == curve_index` + /// \pre `c3t3.curve_index(v1, v2) == curve_index` bool is_sampling_dense_enough(const Vertex_handle& v1, const Vertex_handle& v2, - const Curve_segment_index& curve_index, + const Curve_index& curve_index, const CGAL::Orientation orientation) const; /// Takes an iterator on Vertex_handle as input and check if the sampling @@ -256,11 +256,11 @@ private: /// \c start to \c next is oriented in the same orientation as the curve /// segment with index \c curve_index, or `CGAL::NEGATIVE` otherwise. /// - /// \pre `c3t3.curve_segment_index(v1, v2) == curve_index` + /// \pre `c3t3.curve_index(v1, v2) == curve_index` CGAL::Orientation orientation_of_walk(const Vertex_handle& start, const Vertex_handle& next, - Curve_segment_index curve_index) const; + Curve_index curve_index) const; /// Walk along edge from \c start, following the direction \c start to /// \c next, and fills \c out with the vertices which do not fullfill @@ -270,23 +270,23 @@ private: /// \c v2, given the orientation of the curve of index /// \c curve_index /// - /// \pre `c3t3.curve_segment_index(v1, v2) == curve_index` + /// \pre `c3t3.curve_index(v1, v2) == curve_index` template ErasedVeOutIt walk_along_edge(const Vertex_handle& start, const Vertex_handle& next, - Curve_segment_index curve_index, + Curve_index curve_index, const CGAL::Orientation orientation, ErasedVeOutIt out) const; /// Returns next vertex along edge, i.e vertex after \c start, following /// the direction from \c previous to \c start /// \pre (previous,start) is in c3t3 - /// \pre `c3t3.curve_segment_index(start, previous) == curve_index` + /// \pre `c3t3.curve_index(start, previous) == curve_index` Vertex_handle - next_vertex_along_curve_segment(const Vertex_handle& start, - const Vertex_handle& previous, - const Curve_segment_index& curve_index) const; + next_vertex_along_curve(const Vertex_handle& start, + const Vertex_handle& previous, + const Curve_index& curve_index) const; /// Replace vertices between ]begin,last[ by new vertices, along curve /// identified by \c curve_index @@ -299,7 +299,7 @@ private: template ErasedVeOutIt repopulate(InputIterator begin, InputIterator last, - const Curve_segment_index& curve_index, + const Curve_index& curve_index, const CGAL::Orientation orientation, ErasedVeOutIt out); @@ -307,7 +307,7 @@ private: ErasedVeOutIt analyze_and_repopulate(InputIterator begin, InputIterator last, - const Curve_segment_index& index, + const Curve_index& index, const CGAL::Orientation orientation, ErasedVeOutIt out); @@ -316,7 +316,7 @@ private: bool is_sizing_field_correct(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, - const Curve_segment_index& index, + const Curve_index& index, const CGAL::Orientation orientation) const; /// Repopulate all incident curve around corner \c v @@ -326,13 +326,13 @@ private: repopulate_edges_around_corner(const Vertex_handle& v, ErasedVeOutIt out); /// Returns `true` if edge with index \c curve_index is already treated - bool is_treated(const Curve_segment_index& curve_index) const + bool is_treated(const Curve_index& curve_index) const { return ( treated_edges_.find(curve_index) != treated_edges_.end() ); } /// Set edge with index \c curve_index as treated - void set_treated(const Curve_segment_index& curve_index) + void set_treated(const Curve_index& curve_index) { treated_edges_.insert(curve_index); } @@ -409,7 +409,7 @@ private: SizingFunction size_; FT minimal_size_; Weight minimal_weight_; - std::set treated_edges_; + std::set treated_edges_; std::set unchecked_vertices_; int refine_balls_iteration_nb; bool nonlinear_growth_of_balls; @@ -852,19 +852,19 @@ Protect_edges_sizing_field:: insert_balls_on_edges() { // Get features - typedef CGAL::cpp11::tuple, std::pair > Feature_tuple; typedef std::vector Input_features; Input_features input_features; - domain_.get_curve_segments(std::back_inserter(input_features)); + domain_.get_curves(std::back_inserter(input_features)); // Interate on edges for ( typename Input_features::iterator fit = input_features.begin(), end = input_features.end() ; fit != end ; ++fit ) { - const Curve_segment_index& curve_index = CGAL::cpp11::get<0>(*fit); + const Curve_index& curve_index = CGAL::cpp11::get<0>(*fit); if ( ! is_treated(curve_index) ) { #if CGAL_MESH_3_PROTECTION_DEBUG & 1 @@ -877,7 +877,7 @@ insert_balls_on_edges() const Index& q_index = CGAL::cpp11::get<2>(*fit).second; Vertex_handle vp,vq; - if ( ! domain_.is_cycle(p, curve_index) ) + if ( ! domain_.is_loop(curve_index) ) { vp = get_vertex_corner_from_point(p,p_index); vq = get_vertex_corner_from_point(q,q_index); @@ -897,12 +897,12 @@ insert_balls_on_edges() // with the third of the distance from 'p' to 'q'. FT p_size = query_size(p, 1, p_index); - FT curve_lenght = domain_.curve_segment_length(p, curve_index); + FT curve_lenght = domain_.curve_length(curve_index); Bare_point other_point = - domain_.construct_point_on_curve_segment(p, - curve_index, - curve_lenght / 2); + domain_.construct_point_on_curve(p, + curve_index, + curve_lenght / 2); p_size = (std::min)(p_size, compute_distance(p, other_point) / 3); vp = smart_insert_point(p, @@ -958,7 +958,7 @@ ErasedVeOutIt Protect_edges_sizing_field:: insert_balls(const Vertex_handle& vp, const Vertex_handle& vq, - const Curve_segment_index& curve_index, + const Curve_index& curve_index, const CGAL::Orientation orientation, ErasedVeOutIt out) { @@ -972,13 +972,13 @@ insert_balls(const Vertex_handle& vp, const FT sp = get_radius(vp); const FT sq = get_radius(vq); - CGAL_assertion(vp != vq || domain_.is_cycle(p, curve_index)); + CGAL_assertion(vp != vq || domain_.is_loop(curve_index)); // Compute geodesic distance const FT pq_length = (vp == vq) ? - domain_.curve_segment_length(p, curve_index) + domain_.curve_length(curve_index) : - domain_.arc_length(p, q, curve_index, orientation); + domain_.curve_segment_length(p, q, curve_index, orientation); // Insert balls return @@ -999,7 +999,7 @@ insert_balls(const Vertex_handle& vp, const FT sq, const FT d, const CGAL::Orientation d_sign, - const Curve_segment_index& curve_index, + const Curve_index& curve_index, ErasedVeOutIt out) { typename C3T3::Triangulation::Geom_traits::Construct_point_3 wp2p = @@ -1078,16 +1078,17 @@ insert_balls(const Vertex_handle& vp, << n << "\n between points (" << vp->point() << ") and (" << vq->point() << ") (arc length: " - << domain_.arc_length(wp2p(vp->point()), wp2p(vq->point()), - curve_index, d_sign) + << domain_.curve_segment_length(wp2p(vp->point()), + wp2p(vq->point()), + curve_index, d_sign) << ")\n"; #endif const Bare_point new_point = - domain_.construct_point_on_curve_segment(wp2p(vp->point()), - curve_index, - d_sign * d / 2); + domain_.construct_point_on_curve(wp2p(vp->point()), + curve_index, + d_sign * d / 2); const int dim = 1; // new_point is on edge - const Index index = domain_.index_from_curve_segment_index(curve_index); + const Index index = domain_.index_from_curve_index(curve_index); const FT point_weight = CGAL::square(size_(new_point, dim, index)); #if CGAL_MESH_3_PROTECTION_DEBUG & 1 std::cerr << " middle point: " << new_point << std::endl; @@ -1167,14 +1168,14 @@ insert_balls(const Vertex_handle& vp, { // New point position Bare_point new_point = - domain_.construct_point_on_curve_segment(p, curve_index, pt_dist); + domain_.construct_point_on_curve(p, curve_index, pt_dist); // Weight (use as size the min between norm_step_size and linear interpolation) FT current_size = (std::min)(norm_step_size, sp + CGAL::abs(pt_dist)/d*(sq-sp)); FT point_weight = current_size * current_size; // Index and dimension - Index index = domain_.index_from_curve_segment_index(curve_index); + Index index = domain_.index_from_curve_index(curve_index); int dim = 1; // new_point is on edge // Insert point into c3t3 @@ -1552,7 +1553,7 @@ check_and_fix_vertex_along_edge(const Vertex_handle& v, ErasedVeOutIt out) // mesh is only two balls on the cycle: then each ball has only one // neighbor. - const Curve_segment_index& curve_index = incident_vertices.front().second; + const Curve_index& curve_index = incident_vertices.front().second; CGAL_assertion(incident_vertices.back().second== curve_index); // Walk along edge to find the edge piece which is not correctly sampled @@ -1610,25 +1611,25 @@ template bool Protect_edges_sizing_field:: is_sampling_dense_enough(const Vertex_handle& v1, const Vertex_handle& v2, - const Curve_segment_index& curve_index, + const Curve_index& curve_index, const CGAL::Orientation orientation) const { using CGAL::Mesh_3::internal::min_intersection_factor; - CGAL_precondition(c3t3_.curve_segment_index(v1,v2) == curve_index); + CGAL_precondition(c3t3_.curve_index(v1,v2) == curve_index); // Get sizes FT size_v1 = get_radius(v1); FT size_v2 = get_radius(v2); CGAL_assertion(get_dimension(v1) != 1 || - curve_index == domain_.curve_segment_index(v1->index())); + curve_index == domain_.curve_index(v1->index())); CGAL_assertion(get_dimension(v2) != 1 || - curve_index == domain_.curve_segment_index(v2->index())); + curve_index == domain_.curve_index(v2->index())); - FT arc_length = domain_.arc_length(v1->point().point(), - v2->point().point(), - curve_index, - orientation); + FT arc_length = domain_.curve_segment_length(v1->point().point(), + v2->point().point(), + curve_index, + orientation); // Sufficient condition so that the curve portion between v1 and v2 is // inside the union of the two balls. if(arc_length > (size_v1 + size_v2)) { @@ -1678,19 +1679,19 @@ CGAL::Orientation Protect_edges_sizing_field:: orientation_of_walk(const Vertex_handle& start, const Vertex_handle& next, - Curve_segment_index curve_index) const + Curve_index curve_index) const { typename C3T3::Triangulation::Geom_traits::Construct_point_3 wp2p = c3t3_.triangulation().geom_traits().construct_point_3_object(); - if(domain_.is_cycle(wp2p(start->point()), curve_index)) { + if(domain_.is_loop(curve_index)) { // if the curve is a cycle, the direction is the direction passing // through the next vertex, and the next-next vertex return - (domain_.distance_sign_along_cycle + (domain_.distance_sign_along_loop (wp2p(start->point()), wp2p(next->point()), - wp2p(next_vertex_along_curve_segment(next,start,curve_index)->point()), + wp2p(next_vertex_along_curve(next,start,curve_index)->point()), curve_index)); } else { // otherwise, the sign is just the sign of the geodesic distance @@ -1704,7 +1705,7 @@ template ErasedVeOutIt Protect_edges_sizing_field:: walk_along_edge(const Vertex_handle& start, const Vertex_handle& next, - Curve_segment_index curve_index, + Curve_index curve_index, const CGAL::Orientation orientation, ErasedVeOutIt out) const { @@ -1736,7 +1737,7 @@ walk_along_edge(const Vertex_handle& start, const Vertex_handle& next, // Get next vertex along edge Vertex_handle next = - next_vertex_along_curve_segment(current,previous,curve_index); + next_vertex_along_curve(current,previous,curve_index); previous = current; current = next; } @@ -1748,16 +1749,13 @@ walk_along_edge(const Vertex_handle& start, const Vertex_handle& next, template typename Protect_edges_sizing_field::Vertex_handle Protect_edges_sizing_field:: -next_vertex_along_curve_segment(const Vertex_handle& start, - const Vertex_handle& previous, - const Curve_segment_index& curve_index) const +next_vertex_along_curve(const Vertex_handle& start, + const Vertex_handle& previous, + const Curve_index& curve_index) const { - typename C3T3::Triangulation::Geom_traits::Construct_point_3 wp2p = - c3t3_.triangulation().geom_traits().construct_point_3_object(); - - CGAL_USE(curve_index); CGAL_USE(wp2p); - CGAL_precondition( c3t3_.curve_segment_index(start, previous) == curve_index); - CGAL_precondition( domain_.is_cycle(wp2p(start->point()), curve_index) || + CGAL_USE(curve_index); + CGAL_precondition( c3t3_.curve_index(start, previous) == curve_index); + CGAL_precondition( domain_.is_loop(curve_index) || (! c3t3_.is_in_complex(start)) ); Incident_vertices incident_vertices; @@ -1786,7 +1784,7 @@ template ErasedVeOutIt Protect_edges_sizing_field:: repopulate(InputIterator begin, InputIterator last, - const Curve_segment_index& index, + const Curve_index& index, const CGAL::Orientation orientation, ErasedVeOutIt out) { @@ -1851,7 +1849,7 @@ template ErasedVeOutIt Protect_edges_sizing_field:: analyze_and_repopulate(InputIterator begin, InputIterator last, - const Curve_segment_index& index, + const Curve_index& index, const CGAL::Orientation orientation, ErasedVeOutIt out) { @@ -1928,7 +1926,7 @@ Protect_edges_sizing_field:: is_sizing_field_correct(const Vertex_handle& v1, const Vertex_handle& v2, const Vertex_handle& v3, - const Curve_segment_index& curve_index, + const Curve_index& curve_index, const CGAL::Orientation orientation) const { typename C3T3::Triangulation::Geom_traits::Construct_point_3 wp2p = @@ -1937,10 +1935,10 @@ is_sizing_field_correct(const Vertex_handle& v1, FT s1 = get_radius(v1); FT s2 = get_radius(v2); FT s3 = get_radius(v3); - FT D = domain_.arc_length(wp2p(v1->point()), wp2p(v3->point()), - curve_index, orientation); - FT d = domain_.arc_length(wp2p(v1->point()), wp2p(v2->point()), - curve_index, orientation); + FT D = domain_.curve_segment_length(wp2p(v1->point()), wp2p(v3->point()), + curve_index, orientation); + FT d = domain_.curve_segment_length(wp2p(v1->point()), wp2p(v2->point()), + curve_index, orientation); return ( s2 >= (s1 + d/D*(s3-s1)) ); } @@ -1954,9 +1952,6 @@ repopulate_edges_around_corner(const Vertex_handle& v, ErasedVeOutIt out) { CGAL_precondition(c3t3_.is_in_complex(v)); - typename C3T3::Triangulation::Geom_traits::Construct_point_3 wp2p = - c3t3_.triangulation().geom_traits().construct_point_3_object(); - Incident_vertices incident_vertices; c3t3_.adjacent_vertices_in_complex(v, std::back_inserter(incident_vertices)); @@ -1964,12 +1959,12 @@ repopulate_edges_around_corner(const Vertex_handle& v, ErasedVeOutIt out) vend = incident_vertices.end() ; vit != vend ; ++vit ) { const Vertex_handle& next = vit->first; - const Curve_segment_index& curve_index = vit->second; + const Curve_index& curve_index = vit->second; // if `v` is incident to a cycle, it might be that the full cycle, // including the edge `[next, v]`, has already been processed by // `analyze_and_repopulate()` walking in the other direction. - if(domain_.is_cycle(wp2p(v->point()), curve_index) && + if(domain_.is_loop(curve_index) && !c3t3_.is_in_complex(v, next)) continue; diff --git a/Mesh_3/include/CGAL/Mesh_3/experimental/Facet_topological_criterion_with_adjacency.h b/Mesh_3/include/CGAL/Mesh_3/experimental/Facet_topological_criterion_with_adjacency.h index 984f32780cd..1a6b1a57d23 100644 --- a/Mesh_3/include/CGAL/Mesh_3/experimental/Facet_topological_criterion_with_adjacency.h +++ b/Mesh_3/include/CGAL/Mesh_3/experimental/Facet_topological_criterion_with_adjacency.h @@ -101,7 +101,7 @@ protected: case 1: { ++nb_vertices_on_curves; - const typename MeshDomain::Curve_segment_index curve_id = + const typename MeshDomain::Curve_index curve_id = domain->curve_segment_index(v->index()); Index_set set; domain->get_incidences(curve_id, std::back_inserter(set)); diff --git a/Mesh_3/include/CGAL/Mesh_3/experimental/Lipschitz_sizing_experimental.h b/Mesh_3/include/CGAL/Mesh_3/experimental/Lipschitz_sizing_experimental.h index f224ef85947..ff0fa8702f1 100644 --- a/Mesh_3/include/CGAL/Mesh_3/experimental/Lipschitz_sizing_experimental.h +++ b/Mesh_3/include/CGAL/Mesh_3/experimental/Lipschitz_sizing_experimental.h @@ -205,7 +205,7 @@ public: else if (dim == 1) { #ifdef CGAL_MESH_3_EXPERIMENTAL_USE_PATCHES_IDS - const typename MeshDomain::Curve_segment_index& curve_id = + const typename MeshDomain::Curve_index& curve_id = m_domain.curve_segment_index(index); const Patches_ids& ids = patches_ids_map[curve_id]; diff --git a/Mesh_3/include/CGAL/Mesh_3/experimental/Sizing_field_with_aabb_tree.h b/Mesh_3/include/CGAL/Mesh_3/experimental/Sizing_field_with_aabb_tree.h index 7f88efc24cf..fb3a80f38f3 100644 --- a/Mesh_3/include/CGAL/Mesh_3/experimental/Sizing_field_with_aabb_tree.h +++ b/Mesh_3/include/CGAL/Mesh_3/experimental/Sizing_field_with_aabb_tree.h @@ -51,7 +51,7 @@ struct Sizing_field_with_aabb_tree typedef typename MeshDomain::Index Index; typedef typename MeshDomain::Corner_index Corner_index; - typedef typename MeshDomain::Curve_segment_index Curve_index; + typedef typename MeshDomain::Curve_index Curve_index; typedef typename MeshDomain::Surface_patch_index Patch_index; typedef boost::container::flat_set Curves_ids; @@ -293,7 +293,7 @@ struct Sizing_field_with_aabb_tree return result; } else { // dim == 1 - const typename MeshDomain::Curve_segment_index& curve_id = + const typename MeshDomain::Curve_index& curve_id = domain.curve_segment_index(id); if(!aabb_tree.empty()) { const Patches_ids& ids = curves_incident_patches[curve_id]; diff --git a/Mesh_3/include/CGAL/Mesh_complex_3_in_triangulation_3.h b/Mesh_3/include/CGAL/Mesh_complex_3_in_triangulation_3.h index 7ab36a474e3..2294176ae5d 100644 --- a/Mesh_3/include/CGAL/Mesh_complex_3_in_triangulation_3.h +++ b/Mesh_3/include/CGAL/Mesh_complex_3_in_triangulation_3.h @@ -48,7 +48,7 @@ namespace CGAL { template + typename CurveIndex = int> class Mesh_complex_3_in_triangulation_3 : public Mesh_3::Mesh_complex_3_in_triangulation_3_base< Tr, typename Tr::Concurrency_tag> @@ -59,7 +59,7 @@ public: private: typedef Mesh_complex_3_in_triangulation_3< - Tr,CornerIndex,CurveSegmentIndex> Self; + Tr,CornerIndex,CurveIndex> Self; typedef Mesh_3::Mesh_complex_3_in_triangulation_3_base< Tr,Concurrency_tag> Base; @@ -72,7 +72,11 @@ public: typedef typename Base::Vertex_handle Vertex_handle; typedef typename Base::Cell_handle Cell_handle; typedef CornerIndex Corner_index; - typedef CurveSegmentIndex Curve_segment_index; + typedef CurveIndex Curve_index; + +#ifndef CGAL_NO_DEPRECATED_CODE + CGAL_DEPRECATED typedef CurveIndex Curve_segment_index; +#endif typedef typename Base::Triangulation Triangulation; typedef typename Base::Subdomain_index Subdomain_index; @@ -83,12 +87,12 @@ private: // Type to store the edges: // - a set of std::pair (ordered at insertion) // - which allows fast lookup from one Vertex_handle - // - each element of the set has an associated info (Curve_segment_index) value + // - each element of the set has an associated info (Curve_index) value typedef boost::bimaps::bimap< boost::bimaps::multiset_of, boost::bimaps::multiset_of, boost::bimaps::set_of_relation<>, - boost::bimaps::with_info > Edge_map; + boost::bimaps::with_info > Edge_map; typedef typename Edge_map::value_type Internal_edge; @@ -156,10 +160,10 @@ public: /** - * Add edge e to complex, with Curve_segment_index index + * Add edge e to complex, with Curve_index index */ void add_to_complex(const Edge& e, - const Curve_segment_index& index) + const Curve_index& index) { add_to_complex(e.first->vertex(e.second), e.first->vertex(e.third), @@ -167,11 +171,11 @@ public: } /** - * Add edge (v1,v2) to complex, with Curve_segment_index index + * Add edge (v1,v2) to complex, with Curve_index index */ void add_to_complex(const Vertex_handle& v1, const Vertex_handle& v2, - const Curve_segment_index& index) + const Curve_index& index) { add_to_complex(make_internal_edge(v1,v2), index); } @@ -315,23 +319,35 @@ public: } /** - * Returns Curve_segment_index of edge \c e + * Returns Curve_index of edge \c e */ - Curve_segment_index curve_segment_index(const Edge& e) const + Curve_index curve_index(const Edge& e) const { - return curve_segment_index(e.first->vertex(e.second), - e.first->vertex(e.third)); + return curve_index(e.first->vertex(e.second), + e.first->vertex(e.third)); } - /** - * Returns Curve_segment_index of edge \c (v1,v2) - */ - Curve_segment_index curve_segment_index(const Vertex_handle& v1, - const Vertex_handle& v2) const + Curve_index curve_index(const Vertex_handle& v1, + const Vertex_handle& v2) const { return curve_index(make_internal_edge(v1,v2)); } +#ifndef CGAL_NO_DEPRECATED_CODE + CGAL_DEPRECATED + Curve_index curve_segment_index(const Edge& e) const + { + return curve_index(e); + } + + CGAL_DEPRECATED + Curve_index curve_segment_index(const Vertex_handle& v1, + const Vertex_handle& v2) const + { + return curve_index(v1, v2); + } +#endif // CGAL_NO_DEPRECATED_CODE + /** * Returns Corner_index of vertex \c v */ @@ -371,7 +387,7 @@ public: /** * Fills \c out with incident edges (1-dimensional features of \c v. - * OutputIterator value type is std::pair + * OutputIterator value type is std::pair * \pre v->in_dimension() < 2 */ template @@ -394,18 +410,18 @@ private: class Edge_iterator_not_in_complex { const Self& c3t3_; - const Curve_segment_index index_; + const Curve_index index_; public: Edge_iterator_not_in_complex(const Self& c3t3, - const Curve_segment_index& index = Curve_segment_index()) + const Curve_index& index = Curve_index()) : c3t3_(c3t3) , index_(index) { } template bool operator()(Iterator it) const { - if ( index_ == Curve_segment_index() ) { return ! c3t3_.is_in_complex(*it); } - else { return c3t3_.curve_segment_index(*it) != index_; } + if ( index_ == Curve_index() ) { return ! c3t3_.is_in_complex(*it); } + else { return c3t3_.curve_index(*it) != index_; } } }; @@ -486,7 +502,7 @@ public: /// Returns a Facets_in_complex_iterator to the first facet of the 1D complex Edges_in_complex_iterator - edges_in_complex_begin(const Curve_segment_index& index) const + edges_in_complex_begin(const Curve_index& index) const { return CGAL::filter_iterator(this->triangulation().finite_edges_end(), Edge_iterator_not_in_complex(*this,index), @@ -494,7 +510,7 @@ public: } /// Returns past-the-end iterator on facet of the 1D complex - Edges_in_complex_iterator edges_in_complex_end(const Curve_segment_index& = Curve_segment_index()) const + Edges_in_complex_iterator edges_in_complex_end(const Curve_index& = Curve_index()) const { return CGAL::filter_iterator(this->triangulation().finite_edges_end(), Edge_iterator_not_in_complex(*this)); @@ -544,13 +560,13 @@ private: */ bool is_in_complex(const Internal_edge& edge) const { - return (curve_index(edge) != Curve_segment_index() ); + return (curve_index(edge) != Curve_index() ); } /** - * Add edge \c edge to complex, with Curve_segment_index index + * Add edge \c edge to complex, with Curve_index index */ - void add_to_complex(const Internal_edge& edge, const Curve_segment_index& index) + void add_to_complex(const Internal_edge& edge, const Curve_index& index) { CGAL_precondition(!is_in_complex(edge)); #if CGAL_MESH_3_PROTECTION_DEBUG & 1 @@ -571,13 +587,13 @@ private: } /** - * Returns Curve_segment_index of edge \c edge + * Returns Curve_index of edge \c edge */ - Curve_segment_index curve_index(const Internal_edge& edge) const + Curve_index curve_index(const Internal_edge& edge) const { typename Edge_map::const_iterator it = edges_.find(edge); if ( edges_.end() != it ) { return it->info; } - return Curve_segment_index(); + return Curve_index(); } private: diff --git a/Mesh_3/include/CGAL/Mesh_domain_with_polyline_features_3.h b/Mesh_3/include/CGAL/Mesh_domain_with_polyline_features_3.h index 053012ea18a..88c027244ce 100644 --- a/Mesh_3/include/CGAL/Mesh_domain_with_polyline_features_3.h +++ b/Mesh_3/include/CGAL/Mesh_domain_with_polyline_features_3.h @@ -98,8 +98,8 @@ public: return points_.size() > 1; } - /// Returns `true` if polyline is a cycle - bool is_cycle() const + /// Returns `true` if polyline is a loop + bool is_loop() const { return start_point() == end_point(); } @@ -108,7 +108,7 @@ public: if(orientation == POSITIVE) { CGAL_assertion(it != (points_.end() - 1)); if(it == (points_.end() - 2)) { - CGAL_assertion(is_cycle()); + CGAL_assertion(is_loop()); it = points_.begin(); } else { ++it; @@ -117,7 +117,7 @@ public: CGAL_assertion(orientation == NEGATIVE); CGAL_assertion(it != points_.begin()); if(it == (points_.begin() + 1)) { - CGAL_assertion(is_cycle()); + CGAL_assertion(is_loop()); it = points_.end() - 1; } else { --it; @@ -162,19 +162,19 @@ public: return cover_pred(s1, s2, *c2_it, c2); } - FT arc_length(const Point_3& p, const Point_3 q, - CGAL::Orientation orientation) const + FT curve_segment_length(const Point_3& p, const Point_3 q, + CGAL::Orientation orientation) const { CGAL_assertion(orientation != CGAL::ZERO); const_iterator p_it = locate(p); const_iterator q_it = locate(q); - return arc_length(p, q, orientation, p_it, q_it); + return curve_segment_length(p, q, orientation, p_it, q_it); } - FT arc_length(const Point_3& p, const Point_3 q, - CGAL::Orientation orientation, - const_iterator p_it, - const_iterator q_it) const + FT curve_segment_length(const Point_3& p, const Point_3 q, + CGAL::Orientation orientation, + const_iterator p_it, + const_iterator q_it) const { CGAL_assertion(orientation != CGAL::ZERO); @@ -210,9 +210,9 @@ public: /// Returns the angle at the first point. - /// \pre The polyline must be a cycle. + /// \pre The polyline must be a loop. Angle angle_at_first_point() const { - CGAL_precondition(is_cycle()); + CGAL_precondition(is_loop()); const Point_3& first = points_.front(); const Point_3& next_p = points_[1]; const Point_3& prev = points_[points_.size() - 2]; @@ -253,16 +253,16 @@ public: else { return -result; } } - if(is_cycle()) { - const FT positive_distance = arc_length(p, q, CGAL::POSITIVE, pit, qit); - const FT negative_distance = arc_length(p, q, CGAL::NEGATIVE, pit, qit); + if(is_loop()) { + const FT positive_distance = curve_segment_length(p, q, CGAL::POSITIVE, pit, qit); + const FT negative_distance = curve_segment_length(p, q, CGAL::NEGATIVE, pit, qit); return (positive_distance < negative_distance) ? positive_distance : (- negative_distance); } else { return (pit <= qit) - ? arc_length(p, q, CGAL::POSITIVE) - : ( - arc_length(p, q, CGAL::NEGATIVE) ); + ? curve_segment_length(p, q, CGAL::POSITIVE) + : ( - curve_segment_length(p, q, CGAL::NEGATIVE) ); } } @@ -273,10 +273,10 @@ public: Point_3 point_at(const Point_3& p, FT distance) const { // use first point of the polyline instead of p - distance += arc_length(start_point(),p,CGAL::POSITIVE); + distance += curve_segment_length(start_point(),p,CGAL::POSITIVE); - // If polyline is a cycle, ensure that distance is given from start_point() - if ( is_cycle() ) + // If polyline is a loop, ensure that distance is given from start_point() + if ( is_loop() ) { if ( distance < FT(0) ) { distance += length(); } else if ( distance > length() ) { distance -= length(); } @@ -314,7 +314,7 @@ public: bool are_ordered_along(const Point_3& p, const Point_3& q) const { - CGAL_precondition(!is_cycle()); + CGAL_precondition(!is_loop()); // Locate p & q on polyline const_iterator pit = locate(p); @@ -343,7 +343,7 @@ private: /// Returns an iterator on the starting point of the segment of the /// polyline which contains p /// if end_point_first is true, then --end is returned instead of begin - /// if p is the starting point of a cycle. + /// if p is the starting point of a loop. const_iterator locate(const Point_3& p, bool end_point_first=false) const { CGAL_precondition(is_valid()); @@ -356,7 +356,7 @@ private: { return --result; } else { - // Treat cycles + // Treat loops if ( end_point_first && p == end_point() ) { return last_segment_source(); } else @@ -483,7 +483,7 @@ struct Mesh_domain_segment_of_curve_primitive{ template struct Display_incidences_to_patches_aux { template - void operator()(std::ostream& os, Point p, typename MDwPF::Curve_segment_index id, + void operator()(std::ostream& os, Point p, typename MDwPF::Curve_index id, const Container&) const; }; @@ -491,21 +491,21 @@ template //specialization when patch_id_is_streamable == false struct Display_incidences_to_patches_aux { template void operator()(std::ostream& os, Point p, - typename MDwPF::Curve_segment_index id, + typename MDwPF::Curve_index id, const Container&) const; }; template struct Display_incidences_to_curves_aux { template - void operator()(std::ostream& os, Point p, typename MDwPF::Curve_segment_index id, + void operator()(std::ostream& os, Point p, typename MDwPF::Curve_index id, const Container&) const; }; template //specialization when curve_id_is_streamable == false struct Display_incidences_to_curves_aux { template - void operator()(std::ostream& os, Point p, typename MDwPF::Curve_segment_index id, + void operator()(std::ostream& os, Point p, typename MDwPF::Curve_index id, const Container&) const; }; @@ -534,9 +534,13 @@ public: typedef typename Base::Surface_patch_index Surface_patch_index; - typedef int Curve_segment_index; + typedef int Curve_index; typedef int Corner_index; +#ifndef CGAL_NO_DEPRECATED_CODE + CGAL_DEPRECATED typedef Curve_index Curve_segment_index; +#endif + typedef typename Base::R Gt; typedef Gt R; typedef typename Base::Point_3 Point_3; @@ -599,70 +603,69 @@ public: template OutputIterator get_corners(OutputIterator out) const; - /// OutputIterator value type is CGAL::cpp11::tuple, std::pair > template - OutputIterator get_curve_segments(OutputIterator out) const; + OutputIterator get_curves(OutputIterator out) const; /// Returns the length of the curve segment, on the curve with index /// \c curve_index, from \c p to \c q, in the orientation /// \c orientation /// - /// If the curve connected component containing \c p and \c q is a cycle, - /// the orientation gives identifies which portion of the cycle + /// If the curve containing \c p and \c q is a loop, + /// the orientation gives identifies which portion of the loop /// corresponds to the arc, otherwise \c orientation must be compatible /// with the orientation of \c p and \c q on the curve segment. - FT arc_length(const Point_3& p, const Point_3 q, - const Curve_segment_index& curve_index, - CGAL::Orientation orientation) const; + FT curve_segment_length(const Point_3& p, const Point_3 q, + const Curve_index& curve_index, + CGAL::Orientation orientation) const; - /// Returns the length of the connected component of curve with index - /// \c curve_index including point \c p - FT curve_segment_length(const Point_3& p, - const Curve_segment_index& curve_index) const; + /// Returns the length of the curve with index + /// \c curve_index + FT curve_length(const Curve_index& curve_index) const; /// Returns the signed geodesic distance between points \c p and \c q /// of curve \c curve_index FT signed_geodesic_distance(const Point_3& p, const Point_3& q, - const Curve_segment_index& curve_index) const; + const Curve_index& curve_index) const; /// Construct a point on curve \c curve_index at geodesic distance \c distance /// of \c starting_point Point_3 - construct_point_on_curve_segment(const Point_3& starting_point, - const Curve_segment_index& curve_index, - FT distance) const; + construct_point_on_curve(const Point_3& starting_point, + const Curve_index& curve_index, + FT distance) const; /// Returns the sign of the orientation of p,q,r along curve segment /// of index \c index - CGAL::Sign distance_sign_along_cycle(const Point_3& p, - const Point_3& q, - const Point_3& r, - const Curve_segment_index& index) const; + CGAL::Sign distance_sign_along_loop(const Point_3& p, + const Point_3& q, + const Point_3& r, + const Curve_index& index) const; /// Returns the sign of the geodesic distance between \c p and \c q - /// \pre Curve segment of index \c index is not a cycle + /// \pre Curve of index \c index is not a loop CGAL::Sign distance_sign(const Point_3& p, const Point_3& q, - const Curve_segment_index& index) const; + const Curve_index& index) const; - /// Returns `true` if curve \c curve_index is a cycle - bool is_cycle(const Point_3&, const Curve_segment_index& index) const; + /// Returns `true` if curve \c curve_index is a loop + bool is_loop(const Curve_index& index) const; /// Returns `true` if the portion of the curve segment of index \c index, - /// between the points \c c1 and \c c2, is covered by the spheres of + /// from \c c1 to \c c2 in the orientation \c orientation, is covered by the spheres of /// centers \c c1 and \c c2 and squared radii \c sq_r1 and \c sq_r2 /// respectively. - bool is_curve_segment_covered(const Curve_segment_index& index, + bool is_curve_segment_covered(const Curve_index& index, CGAL::Orientation orientation, const Point_3& c1, const Point_3& c2, const FT sq_r1, const FT sq_r2) const; - /// Returns an Index from a Curve_segment_index - Index index_from_curve_segment_index(const Curve_segment_index& index) const + /// Returns an Index from a Curve_index + Index index_from_curve_index(const Curve_index& index) const { return Index(index); } - /// Returns an Curve_segment_index from an Index - Curve_segment_index curve_segment_index(const Index& index) const - { return boost::get(index); } + /// Returns an Curve_index from an Index + Curve_index curve_index(const Index& index) const + { return boost::get(index); } /// Returns an Index from a Corner_index Index index_from_corner_index(const Corner_index& index) const @@ -676,7 +679,7 @@ public: /// + InputIterator type should have begin() and end() function /// + InputIterator::iterator value type must be Point_3 // + IndicesOutputIterator is an output iterator of value_type equal - /// to Curve_segment_index + /// to Curve_index template IndicesOutputIterator add_features(InputIterator first, InputIterator last, @@ -706,7 +709,7 @@ public: template IndicesOutputIterator - get_incidences(Curve_segment_index id, IndicesOutputIterator out) const; + get_incidences(Curve_index id, IndicesOutputIterator out) const; template IndicesOutputIterator @@ -719,17 +722,17 @@ public: typedef std::set Surface_patch_index_set; const Surface_patch_index_set& - get_incidences(Curve_segment_index id) const; + get_incidences(Curve_index id) const; void display_corner_incidences(std::ostream& os, Point_3, Corner_index id); /// Insert one edge into domain /// InputIterator value type is Point_3 template - Curve_segment_index insert_edge(InputIterator first, InputIterator last); + Curve_index insert_edge(InputIterator first, InputIterator last); private: - void register_corner(const Point_3& p, const Curve_segment_index& index); + void register_corner(const Point_3& p, const Curve_index& index); void compute_corners_incidences(); /// Returns Index associated to p (p must be the coordinates of a corner @@ -740,9 +743,9 @@ private: typedef std::map Corners; typedef internal::Mesh_3::Polyline Polyline; - typedef std::map Edges; - typedef std::map Edges_incidences; - typedef std::map > Corners_tmp_incidences; + typedef std::map Edges; + typedef std::map Edges_incidences; + typedef std::map > Corners_tmp_incidences; typedef std::map Corners_incidences; typedef internal::Mesh_3::Mesh_domain_segment_of_curve_primitive< @@ -758,7 +761,7 @@ private: Corners_incidences corners_incidences_; Edges edges_; - Curve_segment_index current_curve_index_; + Curve_index current_curve_index_; Edges_incidences edges_incidences_; public: @@ -779,8 +782,8 @@ public: if(!curves_aabb_tree_is_built) build_curves_aabb_tree(); return curves_aabb_tree_; } - Curve_segment_index maximal_curve_segment_index() const { - if(edges_incidences_.empty()) return Curve_segment_index(); + Curve_index maximal_curve_index() const { + if(edges_incidences_.empty()) return Curve_index(); return boost::prior(edges_incidences_.end())->first; } @@ -842,7 +845,7 @@ template template OutputIterator Mesh_domain_with_polyline_features_3:: -get_curve_segments(OutputIterator out) const +get_curves(OutputIterator out) const { for ( typename Edges::const_iterator eit = edges_.begin(), end = edges_.end() ; eit != end ; ++eit ) @@ -853,14 +856,14 @@ get_curve_segments(OutputIterator out) const const Point_3& q = eit->second.end_point(); Index p_index, q_index; - if ( ! eit->second.is_cycle() ) + if ( ! eit->second.is_loop() ) { p_index = point_corner_index(p); q_index = point_corner_index(q); } else { - p_index = index_from_curve_segment_index(eit->first); + p_index = index_from_curve_index(eit->first); q_index = p_index; } @@ -892,23 +895,22 @@ point_corner_index(const Point_3& p) const template typename Mesh_domain_with_polyline_features_3::FT Mesh_domain_with_polyline_features_3:: -arc_length(const Point_3& p, const Point_3 q, - const Curve_segment_index& curve_index, - CGAL::Orientation orientation) const +curve_segment_length(const Point_3& p, const Point_3 q, + const Curve_index& curve_index, + CGAL::Orientation orientation) const { // Get corresponding polyline typename Edges::const_iterator eit = edges_.find(curve_index); CGAL_assertion(eit != edges_.end()); - return eit->second.arc_length(p, q, orientation); + return eit->second.curve_segment_length(p, q, orientation); } template typename Mesh_domain_with_polyline_features_3::FT Mesh_domain_with_polyline_features_3:: -curve_segment_length(const Point_3&, - const Curve_segment_index& curve_index) const +curve_length(const Curve_index& curve_index) const { // Get corresponding polyline typename Edges::const_iterator eit = edges_.find(curve_index); @@ -922,7 +924,7 @@ template typename Mesh_domain_with_polyline_features_3::FT Mesh_domain_with_polyline_features_3:: signed_geodesic_distance(const Point_3& p, const Point_3& q, - const Curve_segment_index& curve_index) const + const Curve_index& curve_index) const { // Get corresponding polyline typename Edges::const_iterator eit = edges_.find(curve_index); @@ -936,9 +938,9 @@ signed_geodesic_distance(const Point_3& p, const Point_3& q, template typename Mesh_domain_with_polyline_features_3::Point_3 Mesh_domain_with_polyline_features_3:: -construct_point_on_curve_segment(const Point_3& starting_point, - const Curve_segment_index& curve_index, - FT distance) const +construct_point_on_curve(const Point_3& starting_point, + const Curve_index& curve_index, + FT distance) const { // Get corresponding polyline typename Edges::const_iterator eit = edges_.find(curve_index); @@ -987,7 +989,7 @@ add_features_with_context(InputIterator first, InputIterator last, std::copy(first->context.adjacent_patches_ids.begin(), first->context.adjacent_patches_ids.end(), std::inserter(ids_p2, ids_p2.begin())); - Curve_segment_index curve_id = + Curve_index curve_id = insert_edge(first->polyline_content.begin(), first->polyline_content.end()); edges_incidences_[curve_id] = first->context.adjacent_patches_ids; *indices_out++ = curve_id; @@ -1033,7 +1035,7 @@ template template IndicesOutputIterator Mesh_domain_with_polyline_features_3:: -get_incidences(Curve_segment_index id, +get_incidences(Curve_index id, IndicesOutputIterator indices_out) const { typename Edges_incidences::const_iterator it = edges_incidences_.find(id); @@ -1066,7 +1068,7 @@ get_corner_incident_curves(Corner_index id, { typename Corners_tmp_incidences::const_iterator it = corners_tmp_incidences_.find(id); - const std::set& incidences = it->second; + const std::set& incidences = it->second; return std::copy(incidences.begin(), incidences.end(), indices_out); } @@ -1077,12 +1079,12 @@ template template void Display_incidences_to_curves_aux:: -operator()(std::ostream& os, Point p, typename MDwPF_::Curve_segment_index id, +operator()(std::ostream& os, Point p, typename MDwPF_::Curve_index id, const Container2& corners_tmp_incidences_of_id) const { os << "Corner #" << id << " (" << p << ") is incident to the following curves: {"; - BOOST_FOREACH(typename MDwPF_::Curve_segment_index curve_index, + BOOST_FOREACH(typename MDwPF_::Curve_index curve_index, corners_tmp_incidences_of_id) { os << " " << curve_index; @@ -1095,7 +1097,7 @@ template template void Display_incidences_to_curves_aux:: -operator()(std::ostream& os, Point p, typename MDwPF_::Curve_segment_index id, +operator()(std::ostream& os, Point p, typename MDwPF_::Curve_index id, const Container2& corners_tmp_incidences_of_id) const { os << "Corner #" << id << " (" << p @@ -1109,7 +1111,7 @@ template template void Display_incidences_to_patches_aux:: -operator()(std::ostream& os, Point p, typename MDwPF_::Curve_segment_index id, +operator()(std::ostream& os, Point p, typename MDwPF_::Curve_index id, const Container& corners_incidences_of_id) const { os << "Corner #" << id << " (" << p @@ -1127,7 +1129,7 @@ template template void Display_incidences_to_patches_aux:: -operator()(std::ostream& os, Point p, typename MDwPF_::Curve_segment_index id, +operator()(std::ostream& os, Point p, typename MDwPF_::Curve_index id, const Container& corners_incidences_id) const { os << "Corner #" << id << " (" << p << ") is incident to " @@ -1144,7 +1146,7 @@ display_corner_incidences(std::ostream& os, Point_3 p, Corner_index id) { typedef Mesh_domain_with_polyline_features_3 Mdwpf; typedef is_streamable i_s_spi; - typedef is_streamable i_s_csi; + typedef is_streamable i_s_csi; using namespace internal::Mesh_3; typedef Display_incidences_to_curves_aux D_i_t_c; @@ -1168,13 +1170,13 @@ compute_corners_incidences() corner_tmp_incidences = corners_tmp_incidences_[id]; // If the corner is incident to only one curve, and that curve is a - // cycle, then remove the corner from the set, only if the angle is not + // loop, then remove the corner from the set, only if the angle is not // acute. If the angle is acute, the corner must remain as a corner, // to deal correctly with the angle. if(corner_tmp_incidences.size() == 1 && - is_cycle(Point_3(), *corner_tmp_incidences.begin())) + is_loop(*corner_tmp_incidences.begin())) { - const Curve_segment_index curve_id = *corner_tmp_incidences.begin(); + const Curve_index curve_id = *corner_tmp_incidences.begin(); const Polyline& polyline = edges_[curve_id]; if(polyline.angle_at_first_point() == OBTUSE) { typename Corners::iterator to_erase = cit; @@ -1187,7 +1189,7 @@ compute_corners_incidences() Surface_patch_index_set& incidences = corners_incidences_[id]; // That should be an empty set. - BOOST_FOREACH(Curve_segment_index curve_index, corner_tmp_incidences) + BOOST_FOREACH(Curve_index curve_index, corner_tmp_incidences) { get_incidences(curve_index, std::inserter(incidences, @@ -1205,7 +1207,7 @@ compute_corners_incidences() template const typename Mesh_domain_with_polyline_features_3::Surface_patch_index_set& Mesh_domain_with_polyline_features_3:: -get_incidences(Curve_segment_index id) const +get_incidences(Curve_index id) const { typename Edges_incidences::const_iterator it = edges_incidences_.find(id); return it->second; @@ -1214,7 +1216,7 @@ get_incidences(Curve_segment_index id) const template void Mesh_domain_with_polyline_features_3:: -register_corner(const Point_3& p, const Curve_segment_index& curve_index) +register_corner(const Point_3& p, const Curve_index& curve_index) { typename Corners::iterator cit = corners_.lower_bound(p); @@ -1236,20 +1238,20 @@ register_corner(const Point_3& p, const Curve_segment_index& curve_index) template template -typename Mesh_domain_with_polyline_features_3::Curve_segment_index +typename Mesh_domain_with_polyline_features_3::Curve_index Mesh_domain_with_polyline_features_3:: insert_edge(InputIterator first, InputIterator last) { CGAL_assertion(std::distance(first,last) > 1); - const Curve_segment_index curve_index = current_curve_index_++; + const Curve_index curve_index = current_curve_index_++; // Fill corners // - // For a cycle, the "first" point of the cycle is registered as a + // For a loop, the "first" point of the loop is registered as a // corner. If at the end, during the call to // 'compute_corners_incidences()', that corner is incident only to a - // cycle, then it will be removed from the set of corners. + // loop, then it will be removed from the set of corners. register_corner(*first, curve_index); if ( *first != *boost::prior(last) ) { @@ -1273,11 +1275,11 @@ template CGAL::Sign Mesh_domain_with_polyline_features_3:: distance_sign(const Point_3& p, const Point_3& q, - const Curve_segment_index& index) const + const Curve_index& index) const { typename Edges::const_iterator eit = edges_.find(index); CGAL_assertion(eit != edges_.end()); - CGAL_precondition( ! eit->second.is_cycle() ); + CGAL_precondition( ! eit->second.is_loop() ); if ( p == q ) return CGAL::ZERO; @@ -1291,10 +1293,10 @@ distance_sign(const Point_3& p, const Point_3& q, template CGAL::Sign Mesh_domain_with_polyline_features_3:: -distance_sign_along_cycle(const Point_3& p, - const Point_3& q, - const Point_3& r, - const Curve_segment_index& index) const +distance_sign_along_loop(const Point_3& p, + const Point_3& q, + const Point_3& r, + const Curve_index& index) const { CGAL_assertion(p != q); CGAL_assertion(p != r); @@ -1303,10 +1305,10 @@ distance_sign_along_cycle(const Point_3& p, // Find edge typename Edges::const_iterator eit = edges_.find(index); CGAL_assertion(eit != edges_.end()); - CGAL_assertion(eit->second.is_cycle()); + CGAL_assertion(eit->second.is_loop()); - FT pq = eit->second.arc_length(p,q,CGAL::POSITIVE); - FT pr = eit->second.arc_length(p,r,CGAL::POSITIVE); + FT pq = eit->second.curve_segment_length(p,q,CGAL::POSITIVE); + FT pr = eit->second.curve_segment_length(p,r,CGAL::POSITIVE); // Compare pq and pr if ( pq <= pr ) { return CGAL::POSITIVE; } @@ -1316,19 +1318,19 @@ distance_sign_along_cycle(const Point_3& p, template bool Mesh_domain_with_polyline_features_3:: -is_cycle(const Point_3&, const Curve_segment_index& index) const +is_loop(const Curve_index& index) const { // Find edge typename Edges::const_iterator eit = edges_.find(index); CGAL_assertion(eit != edges_.end()); - return eit->second.is_cycle(); + return eit->second.is_loop(); } template bool Mesh_domain_with_polyline_features_3:: -is_curve_segment_covered(const Curve_segment_index& index, +is_curve_segment_covered(const Curve_index& index, CGAL::Orientation orientation, const Point_3& c1, const Point_3& c2, const FT sq_r1, const FT sq_r2) const diff --git a/Mesh_3/include/CGAL/Polyhedral_complex_mesh_domain_3.h b/Mesh_3/include/CGAL/Polyhedral_complex_mesh_domain_3.h index 9b5cf9985e8..efbd606ff84 100644 --- a/Mesh_3/include/CGAL/Polyhedral_complex_mesh_domain_3.h +++ b/Mesh_3/include/CGAL/Polyhedral_complex_mesh_domain_3.h @@ -313,7 +313,7 @@ public: /// @{ /// The types are `int` or types compatible with `int`. typedef typename Base::Corner_index Corner_index; - typedef typename Base::Curve_segment_index Curve_segment_index; + typedef typename Base::Curve_index Curve_index; typedef typename Base::Surface_patch_index Surface_patch_index; typedef typename Base::Subdomain_index Subdomain_index; /// @} @@ -338,7 +338,7 @@ public: typedef CGAL::Tag_true Has_features; typedef std::vector Bare_polyline; - typedef Mesh_3::Polyline_with_context Polyline_with_context; /// @endcond diff --git a/Mesh_3/include/CGAL/Polyhedral_mesh_domain_with_features_3.h b/Mesh_3/include/CGAL/Polyhedral_mesh_domain_with_features_3.h index 329b1fe0e0e..e3754196d83 100644 --- a/Mesh_3/include/CGAL/Polyhedral_mesh_domain_with_features_3.h +++ b/Mesh_3/include/CGAL/Polyhedral_mesh_domain_with_features_3.h @@ -222,10 +222,14 @@ public: // Index types typedef typename Base::Index Index; typedef typename Base::Corner_index Corner_index; - typedef typename Base::Curve_segment_index Curve_segment_index; + typedef typename Base::Curve_index Curve_index; typedef typename Base::Surface_patch_index Surface_patch_index; typedef typename Base::Subdomain_index Subdomain_index; +#ifndef CGAL_NO_DEPRECATED_CODE + CGAL_DEPRECATED typedef Curve_index Curve_segment_index; ///< Backward-compatibility +#endif + typedef typename boost::property_map >::type Face_patch_id_pmap; @@ -244,7 +248,7 @@ public: typedef CGAL::Tag_true Has_features; typedef std::vector Bare_polyline; - typedef Mesh_3::Polyline_with_context Polyline_with_context; /// Constructors Polyhedral_mesh_domain_with_features_3(const Polyhedron& p, diff --git a/Mesh_3/include/CGAL/internal/Mesh_3/get_index.h b/Mesh_3/include/CGAL/internal/Mesh_3/get_index.h index ec4efa0e219..db9b6cf8e05 100644 --- a/Mesh_3/include/CGAL/internal/Mesh_3/get_index.h +++ b/Mesh_3/include/CGAL/internal/Mesh_3/get_index.h @@ -64,7 +64,7 @@ struct Read_mesh_domain_index { return ci; break; case 1: - typename MT::Curve_segment_index si; + typename MT::Curve_index si; if(is_ascii(is)) is >> si; else CGAL::read(is, si); return si; @@ -83,7 +83,7 @@ struct Write_mesh_domain_index { typedef Mesh_domain MT; // was named "mesh traits" previously typedef typename MT::Corner_index Ci; - typedef typename MT::Curve_segment_index Si; + typedef typename MT::Curve_index Si; void operator()(std::ostream& os, int dimension, diff --git a/Mesh_3/test/Mesh_3/test_c3t3_io.cpp b/Mesh_3/test/Mesh_3/test_c3t3_io.cpp index 7810a8ea419..68099de91f1 100644 --- a/Mesh_3/test/Mesh_3/test_c3t3_io.cpp +++ b/Mesh_3/test/Mesh_3/test_c3t3_io.cpp @@ -19,7 +19,7 @@ struct MD_homogeneous_types { typedef CGAL::Tag_false Has_features; typedef int Subdomain_index; typedef int Surface_patch_index; - typedef int Curve_segment_index; + typedef int Curve_index; typedef int Corner_index; typedef int Index; @@ -27,8 +27,8 @@ struct MD_homogeneous_types { static Subdomain_index get_sub_domain_index_2() { return 2; } static Surface_patch_index get_surface_patch_index_1() { return 3; } static Surface_patch_index get_surface_patch_index_2() { return 4; } - static Curve_segment_index get_curve_segment_index_1() { return 5; } - static Curve_segment_index get_curve_segment_index_2() { return 6; } + static Curve_index get_curve_index_1() { return 5; } + static Curve_index get_curve_index_2() { return 6; } static Corner_index get_corner_index_1() { return 7; } static Corner_index get_corner_index_2() { return 8; } @@ -44,18 +44,18 @@ struct MD_heterogeneous_types { enum Subdomain_index_enum { Z = 0, A, B, C, D}; typedef Subdomain_index_enum Subdomain_index; typedef std::pair Surface_patch_index; - typedef int Curve_segment_index; + typedef int Curve_index; typedef double Corner_index; typedef boost::variant Index; static Subdomain_index get_sub_domain_index_1() { return A; } static Subdomain_index get_sub_domain_index_2() { return B; } static Surface_patch_index get_surface_patch_index_1() { return std::make_pair(1, 2); } static Surface_patch_index get_surface_patch_index_2() { return std::make_pair(3, 4); } - static Curve_segment_index get_curve_segment_index_1() { return 5; } - static Curve_segment_index get_curve_segment_index_2() { return 6; } + static Curve_index get_curve_index_1() { return 5; } + static Curve_index get_curve_index_2() { return 6; } static Corner_index get_corner_index_1() { return 7.; } static Corner_index get_corner_index_2() { return 8.; } @@ -201,7 +201,7 @@ template struct Test_c3t3_io { typedef typename Mesh_domain::Subdomain_index Subdomain_index; typedef typename Mesh_domain::Surface_patch_index Surface_patch_index; - typedef typename Mesh_domain::Curve_segment_index Curve_segment_index; + typedef typename Mesh_domain::Curve_index Curve_index; typedef typename Mesh_domain::Corner_index Corner_index; typedef typename Mesh_domain::Index Index; @@ -209,7 +209,7 @@ struct Test_c3t3_io { typedef CGAL::Mesh_complex_3_in_triangulation_3< Tr, Corner_index, - Curve_segment_index + Curve_index > C3t3; typedef typename Tr::Point Point; @@ -422,8 +422,8 @@ struct Test_c3t3_io { c3t3.add_to_complex(c2, Mesh_domain::get_sub_domain_index_2()); c3t3.add_to_complex(f1, Mesh_domain::get_surface_patch_index_1()); c3t3.add_to_complex(f2, Mesh_domain::get_surface_patch_index_2()); - c3t3.add_to_complex(e1, Mesh_domain::get_curve_segment_index_1()); - c3t3.add_to_complex(e2, Mesh_domain::get_curve_segment_index_2()); + c3t3.add_to_complex(e1, Mesh_domain::get_curve_index_1()); + c3t3.add_to_complex(e2, Mesh_domain::get_curve_index_2()); c3t3.add_to_complex(v1, Mesh_domain::get_corner_index_1()); c3t3.add_to_complex(v2, Mesh_domain::get_corner_index_2()); @@ -433,9 +433,9 @@ struct Test_c3t3_io { v2->set_dimension(0); v2->set_index(Mesh_domain::get_corner_index_2()); v3->set_dimension(1); - v3->set_index(Mesh_domain::get_curve_segment_index_1()); + v3->set_index(Mesh_domain::get_curve_index_1()); v4->set_dimension(1); - v4->set_index(Mesh_domain::get_curve_segment_index_2()); + v4->set_index(Mesh_domain::get_curve_index_2()); v5->set_dimension(2); v5->set_index(Mesh_domain::get_surface_patch_index_1()); v6->set_dimension(3); diff --git a/Mesh_3/test/Mesh_3/test_c3t3_with_features.cpp b/Mesh_3/test/Mesh_3/test_c3t3_with_features.cpp index 92c1d86f91b..c5b800e2c4a 100644 --- a/Mesh_3/test/Mesh_3/test_c3t3_with_features.cpp +++ b/Mesh_3/test/Mesh_3/test_c3t3_with_features.cpp @@ -45,7 +45,7 @@ struct Tester typedef CGAL::Mesh_domain_with_polyline_features_3 Md; typedef typename CGAL::Mesh_triangulation_3::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3< - Tr, typename Md::Corner_index, typename Md::Curve_segment_index> C3t3; + Tr, typename Md::Corner_index, typename Md::Curve_index> C3t3; typedef typename Tr::Bare_point Bare_point; typedef typename Tr::Weighted_point Weighted_point; @@ -61,7 +61,7 @@ struct Tester typedef typename C3t3::Edges_in_complex_iterator Edge_iterator; typedef typename C3t3::Vertices_in_complex_iterator Vertices_iterator; - typedef typename C3t3::Curve_segment_index Curve_segment_index; + typedef typename C3t3::Curve_index Curve_index; typedef typename C3t3::Corner_index Corner_index; typedef typename C3t3::Index Index; @@ -99,9 +99,9 @@ struct Tester Corner_index corner_index (1); Corner_index corner_index_bis (2); - Curve_segment_index curve_segment_index (1); - Curve_segment_index curve_segment_index_bis (2); - Index vertex_index (curve_segment_index); + Curve_index curve_index (1); + Curve_index curve_index_bis (2); + Index vertex_index (curve_index); //------------------------------------------------------- // Add edge to c3t3 and verify @@ -116,7 +116,7 @@ struct Tester const Vertex_handle& ev1 = e.first->vertex(e.second); const Vertex_handle& ev2 = e.first->vertex(e.third); - c3t3.add_to_complex(e,curve_segment_index); + c3t3.add_to_complex(e,curve_index); std::cerr << "\tNumber of edges in c3t3: " << c3t3.number_of_edges_in_complex() << std::endl; @@ -129,7 +129,7 @@ struct Tester c3t3.edges_in_complex_end()))); assert(c3t3.is_in_complex(e)); assert(c3t3.is_in_complex(ev1, ev2)); - assert(c3t3.curve_segment_index(e) == curve_segment_index); + assert(c3t3.curve_index(e) == curve_index); //------------------------------------------------------- // Remove cell from c3t3 and verify @@ -146,8 +146,8 @@ struct Tester assert(c3t3.number_of_edges_in_complex() == 0); assert(! c3t3.is_in_complex(e)); assert(! c3t3.is_in_complex(ev1, ev2)); - assert(c3t3.curve_segment_index(e) == Curve_segment_index()); - assert(c3t3.curve_segment_index(ev1, ev2) == Curve_segment_index()); + assert(c3t3.curve_index(e) == Curve_index()); + assert(c3t3.curve_index(ev1, ev2) == Curve_index()); //------------------------------------------------------- // Add corner to c3t3 and verify @@ -191,9 +191,9 @@ struct Tester //------------------------------------------------------- std::cerr << "Insert 1 curve segment (3 edges + 2 corners) in c3t3" << std::endl; - c3t3.add_to_complex(vp1,vp2,curve_segment_index); - c3t3.add_to_complex(vp2,vp3,curve_segment_index); - c3t3.add_to_complex(vp3,vp4,curve_segment_index); + c3t3.add_to_complex(vp1,vp2,curve_index); + c3t3.add_to_complex(vp2,vp3,curve_index); + c3t3.add_to_complex(vp3,vp4,curve_index); c3t3.add_to_complex(vp1,corner_index); c3t3.add_to_complex(vp4,corner_index); c3t3.set_dimension(vp1,0); @@ -229,7 +229,7 @@ struct Tester //------------------------------------------------------- // Check adjacencies //------------------------------------------------------- - std::vector > incident_vertices; + std::vector > incident_vertices; c3t3.adjacent_vertices_in_complex(vp1,std::back_inserter(incident_vertices)); assert(incident_vertices.size() == 1); @@ -259,7 +259,7 @@ struct Tester c3t3_bis.triangulation().insert(points.begin(),points.end()); Edge e_bis = *(c3t3_bis.triangulation().finite_edges_begin()); - c3t3_bis.add_to_complex(e_bis,curve_segment_index_bis); + c3t3_bis.add_to_complex(e_bis,curve_index_bis); Vertex_handle v_bis = ++c3t3_bis.triangulation().finite_vertices_begin(); c3t3_bis.add_to_complex(v_bis,corner_index_bis); @@ -317,24 +317,24 @@ struct Tester std::cout << "Test edge iterators\n"; const Edge& edge_to_modify = *(c3t3.edges_in_complex_begin()); c3t3.remove_from_complex(edge_to_modify); - c3t3.add_to_complex(edge_to_modify,curve_segment_index_bis); + c3t3.add_to_complex(edge_to_modify,curve_index_bis); typename C3t3::Edges_in_complex_iterator curve_eit = - c3t3.edges_in_complex_begin(curve_segment_index); + c3t3.edges_in_complex_begin(curve_index); typename C3t3::Edges_in_complex_iterator curve_eit_bis = - c3t3.edges_in_complex_begin(curve_segment_index_bis); + c3t3.edges_in_complex_begin(curve_index_bis); typename C3t3::Edges_in_complex_iterator eend = c3t3.edges_in_complex_end(); - std::cout << "\tNumber of edges of index '" << curve_segment_index << "': " + std::cout << "\tNumber of edges of index '" << curve_index << "': " << std::distance(curve_eit,eend) << std::endl; - std::cout << "\tNumber of edges of index '" << curve_segment_index_bis << "': " + std::cout << "\tNumber of edges of index '" << curve_index_bis << "': " << std::distance(curve_eit_bis,eend) << std::endl; assert ( std::distance(curve_eit,eend) == 2 ); assert ( std::distance(curve_eit_bis,eend) == 1 ); - assert ( c3t3.curve_segment_index(*curve_eit) == curve_segment_index ); - assert ( c3t3.curve_segment_index(*curve_eit_bis) == curve_segment_index_bis ); + assert ( c3t3.curve_index(*curve_eit) == curve_index ); + assert ( c3t3.curve_index(*curve_eit_bis) == curve_index_bis ); //------------------------------------------------------- // Test vertex iterators diff --git a/Mesh_3/test/Mesh_3/test_domain_with_polyline_features.cpp b/Mesh_3/test/Mesh_3/test_domain_with_polyline_features.cpp index 467e45cb665..dafcbbee091 100644 --- a/Mesh_3/test/Mesh_3/test_domain_with_polyline_features.cpp +++ b/Mesh_3/test/Mesh_3/test_domain_with_polyline_features.cpp @@ -51,7 +51,7 @@ class Domain_with_polyline_tester typedef std::list Polylines; typedef Mesh_domain::Corner_index Ci; - typedef Mesh_domain::Curve_segment_index Csi; + typedef Mesh_domain::Curve_index Csi; typedef Mesh_domain::Index Index; typedef std::vector > Corners_vector; @@ -64,7 +64,7 @@ public: : p1_(1,0,0), p2_(1,1,0), p3_(1,2,0.1), p4_(0.9, 0.9, 1) { } - void build_curve_segment() + void build_curve() { Polylines polylines (1); Polyline& polyline = polylines.front(); @@ -90,7 +90,7 @@ public: domain_.add_features(polylines.begin(),polylines.end()); } - void test_curve_segment_corners() const + void test_curve_corners() const { Corners_vector corners; domain_.get_corners(std::back_inserter(corners)); @@ -108,7 +108,7 @@ public: assert(corners.size() == 1); } - void test_curve_segments() const + void test_curves() const { std::pair extremities = get_extremities(); @@ -129,10 +129,10 @@ public: std::pair extremities = get_extremities(); const Point& p = extremities.first; const Point& q = extremities.second; - const Csi& curve_index = get_curve_segment_index(); + const Csi& curve_index = get_curve_index(); const FT geod (1.3); - Point r = domain_.construct_point_on_curve_segment(p,curve_index,geod); + Point r = domain_.construct_point_on_curve(p,curve_index,geod); const FT& pq_geo = domain_.signed_geodesic_distance(p,q,curve_index); assert(CGAL::squared_distance(p,r) < CGAL::square(geod)); @@ -144,12 +144,12 @@ public: private: std::pair get_extremities() const { - Curves_vector curve_segments; - domain_.get_curve_segments(std::back_inserter(curve_segments)); - assert(curve_segments.size() == 1); + Curves_vector curves; + domain_.get_curves(std::back_inserter(curves)); + assert(curves.size() == 1); - const Point& p = get_first_point(curve_segments.front()); - const Point& q = get_second_point(curve_segments.front()); + const Point& p = get_first_point(curves.front()); + const Point& q = get_second_point(curves.front()); return std::make_pair(p,q); } @@ -164,16 +164,16 @@ private: return CGAL::cpp11::get<2>(tuple).first; } - Csi get_curve_segment_index() const + Csi get_curve_index() const { - Curves_vector curve_segments; - domain_.get_curve_segments(std::back_inserter(curve_segments)); - assert(curve_segments.size() == 1); + Curves_vector curves; + domain_.get_curves(std::back_inserter(curves)); + assert(curves.size() == 1); - return get_curve_segment_index(curve_segments.front()); + return get_curve_index(curves.front()); } - Csi get_curve_segment_index(const Curve_tuple& tuple) const + Csi get_curve_index(const Curve_tuple& tuple) const { return CGAL::cpp11::get<0>(tuple); } @@ -193,10 +193,10 @@ int main() { std::cout << "Test curve segments" << std::endl; Domain_with_polyline_tester domain_tester; - domain_tester.build_curve_segment(); + domain_tester.build_curve(); - domain_tester.test_curve_segment_corners(); - domain_tester.test_curve_segments(); + domain_tester.test_curve_corners(); + domain_tester.test_curves(); domain_tester.test_geodesic_distance(); std::cout << "Test cycles" << std::endl; diff --git a/Mesh_3/test/Mesh_3/test_mesh_3_issue_1554.cpp b/Mesh_3/test/Mesh_3/test_mesh_3_issue_1554.cpp index ca2dd18aa9d..998e4588162 100644 --- a/Mesh_3/test/Mesh_3/test_mesh_3_issue_1554.cpp +++ b/Mesh_3/test/Mesh_3/test_mesh_3_issue_1554.cpp @@ -28,7 +28,7 @@ typedef Tr::Geom_traits Gt; typedef CGAL::Mesh_complex_3_in_triangulation_3 C3t3; + Mesh_domain::Curve_index> C3t3; // Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria; diff --git a/Mesh_3/test/Mesh_3/test_meshing_determinism.cpp b/Mesh_3/test/Mesh_3/test_meshing_determinism.cpp index 687ebefc478..c3713a251eb 100644 --- a/Mesh_3/test/Mesh_3/test_meshing_determinism.cpp +++ b/Mesh_3/test/Mesh_3/test_meshing_determinism.cpp @@ -22,7 +22,7 @@ typedef CGAL::Polyhedral_mesh_domain_with_features_3 Mesh_domain; // Triangulation typedef CGAL::Mesh_triangulation_3::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3< - Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_segment_index> C3t3; + Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_index> C3t3; // Mesh Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria; diff --git a/Mesh_3/test/Mesh_3/test_meshing_polyhedral_complex.cpp b/Mesh_3/test/Mesh_3/test_meshing_polyhedral_complex.cpp index 4cfdfd40247..b4946e6c08a 100644 --- a/Mesh_3/test/Mesh_3/test_meshing_polyhedral_complex.cpp +++ b/Mesh_3/test/Mesh_3/test_meshing_polyhedral_complex.cpp @@ -61,7 +61,7 @@ struct Polyhedral_complex_tester : public Tester typedef CGAL::Mesh_complex_3_in_triangulation_3< Tr, typename Mesh_domain::Corner_index, - typename Mesh_domain::Curve_segment_index> C3t3; + typename Mesh_domain::Curve_index> C3t3; typedef CGAL::Mesh_criteria_3 Mesh_criteria; //Input diff --git a/Mesh_3/test/Mesh_3/test_meshing_polyhedron_with_features.cpp b/Mesh_3/test/Mesh_3/test_meshing_polyhedron_with_features.cpp index 43c372cf6ed..66f2090b6f5 100644 --- a/Mesh_3/test/Mesh_3/test_meshing_polyhedron_with_features.cpp +++ b/Mesh_3/test/Mesh_3/test_meshing_polyhedron_with_features.cpp @@ -47,7 +47,7 @@ struct Polyhedron_with_features_tester : public Tester typedef CGAL::Mesh_complex_3_in_triangulation_3 < Tr, typename Mesh_domain::Corner_index, - typename Mesh_domain::Curve_segment_index > C3t3; + typename Mesh_domain::Curve_index > C3t3; typedef CGAL::Mesh_criteria_3 Mesh_criteria; typedef typename Mesh_criteria::Edge_criteria Edge_criteria; diff --git a/Mesh_3/test/Mesh_3/test_meshing_polylines_only.cpp b/Mesh_3/test/Mesh_3/test_meshing_polylines_only.cpp index 7da0c1847cd..e3cbc677b06 100644 --- a/Mesh_3/test/Mesh_3/test_meshing_polylines_only.cpp +++ b/Mesh_3/test/Mesh_3/test_meshing_polylines_only.cpp @@ -20,7 +20,7 @@ typedef CGAL::Mesh_polyhedron_3::type Polyhedron; // Triangulation typedef CGAL::Mesh_triangulation_3::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3< - Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_segment_index> C3t3; + Tr,Mesh_domain::Corner_index,Mesh_domain::Curve_index> C3t3; // Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria; diff --git a/Mesh_3/test/Mesh_3/test_meshing_unit_tetrahedron.cpp b/Mesh_3/test/Mesh_3/test_meshing_unit_tetrahedron.cpp index 85ba74618fb..52b4e3911c6 100644 --- a/Mesh_3/test/Mesh_3/test_meshing_unit_tetrahedron.cpp +++ b/Mesh_3/test/Mesh_3/test_meshing_unit_tetrahedron.cpp @@ -26,7 +26,7 @@ struct Polyhedron_tester : public Tester Concurrency_tag>::type Tr; typedef CGAL::Mesh_complex_3_in_triangulation_3 C3t3; + typename Mesh_domain::Curve_index> C3t3; // Criteria typedef CGAL::Mesh_criteria_3 Mesh_criteria;