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

use lower case for partition traits descriptors

This commit is contained in:
Mael Rouxel-Labbé 2024-02-29 12:10:29 +01:00
parent d1820195cc
commit 093cc2f93f
15 changed files with 138 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingDomain_3.h
View File

@ -44,41 +44,41 @@ public:
A descriptor that uniquely identifies a vertex.
Must be a model of the concepts `DefaultConstructible`, `CopyConstructible`, and `Assignable`.
*/
typedef unspecified_type Vertex_descriptor;
typedef unspecified_type vertex_descriptor;
/*!
A descriptor that uniquely identifies an edge.
Must be a model of the concepts `DefaultConstructible`, `CopyConstructible`, and `Assignable`.
*/
typedef unspecified_type Edge_descriptor;
typedef unspecified_type edge_descriptor;
/*!
A descriptor that uniquely identifies a cell.
Must be a model of the concepts `DefaultConstructible`, `CopyConstructible`, and `Assignable`.
*/
typedef unspecified_type Cell_descriptor;
typedef unspecified_type cell_descriptor;
/*!
A container for the two vertices of an edge.
Must be a model of the concept `RandomAccessContainer` of size `2` whose value type is `Vertex_descriptor`.
Must be a model of the concept `RandomAccessContainer` of size `2` whose value type is `vertex_descriptor`.
*/
typedef unspecified_type Vertices_incident_to_edge;
/*!
A container for the cells incident to an edge.
Must be a model of the concept `ForwardRange` whose value type is `Cell_descriptor`.
Must be a model of the concept `ForwardRange` whose value type is `cell_descriptor`.
*/
typedef unspecified_type Cells_incident_to_edge;
/*!
A container for the vertices of a cell.
Must be a model of the concept `ForwardRange` whose value type is `Vertex_descriptor`.
Must be a model of the concept `ForwardRange` whose value type is `vertex_descriptor`.
*/
typedef unspecified_type Cell_vertices;
/*!
A container for the edges of a cell.
Must be a model of the concept `ForwardRange` whose value type is `Edge_descriptor`.
Must be a model of the concept `ForwardRange` whose value type is `edge_descriptor`.
*/
typedef unspecified_type Cell_edges;
@ -97,7 +97,7 @@ public:
/*!
returns the 3D position of the vertex `v`.
*/
Point_3 point(const Vertex_descriptor& v) const;
Point_3 point(const vertex_descriptor& v) const;
/*!
returns the value of the values field at the point `p`.
@ -107,34 +107,34 @@ public:
/*!
returns the value of the values field at the vertex `v`.
*/
FT value(const Vertex_descriptor& v) const;
FT value(const vertex_descriptor& v) const;
/*!
returns the two vertices incident to the edge `e`.
*/
Vertices_incident_to_edge incident_vertices(const Edge_descriptor& e) const;
Vertices_incident_to_edge incident_vertices(const edge_descriptor& e) const;
/*!
returns all the cells incident to the edge `e`, in a geometrically ordered manner around the edge.
*/
Cells_incident_to_edge incident_cells(const Edge_descriptor& e) const;
Cells_incident_to_edge incident_cells(const edge_descriptor& e) const;
/*!
returns all the vertices of the cell `c`.
*/
Cell_vertices cell_vertices(const Cell_descriptor& c) const;
Cell_vertices cell_vertices(const cell_descriptor& c) const;
/*!
returns all the edges of the cell `c`.
*/
Cell_edges cell_edges(const Cell_descriptor& c) const;
Cell_edges cell_edges(const cell_descriptor& c) const;
/*!
iterates over all vertices, and calls the functor `f` on each one.
\tparam ConcurrencyTag decides if the vertices are iterated sequentially or in parallel.
Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
\tparam Functor must implement `void operator()(const Vertex_descriptor& vertex)`
\tparam Functor must implement `void operator()(const vertex_descriptor& vertex)`
\param f the functor called on every vertex
*/
@ -146,7 +146,7 @@ public:
\tparam ConcurrencyTag decides if the edges are iterated sequentially or in parallel.
Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
\tparam Functor must implement `void operator()(const Edge_descriptor& edge)`.
\tparam Functor must implement `void operator()(const edge_descriptor& edge)`.
\param f the functor called on every edge
*/
@ -158,7 +158,7 @@ public:
\tparam ConcurrencyTag decides if the cells are iterated sequentially or in parallel.
Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
\tparam Functor must implement `void operator()(const Cell_descriptor& cell)`.
\tparam Functor must implement `void operator()(const cell_descriptor& cell)`.
\param f the functor called on every cell
*/

4
Isosurfacing_3/doc/Isosurfacing_3/Concepts/IsosurfacingValueField_3.h
View File

@ -33,7 +33,7 @@ public:
/*!
* A descriptor that uniquely identifies a vertex (see `IsosurfacingPartition_3`).
*/
typedef unspecified_type Vertex_descriptor;
typedef unspecified_type vertex_descriptor;
/*!
returns the value of the value field at the point `p`.
@ -43,5 +43,5 @@ public:
/*!
returns the value of the value field at the vertex `v`.
*/
FT operator()(const Vertex_descriptor& v);
FT operator()(const vertex_descriptor& v);
};

30
Isosurfacing_3/doc/Isosurfacing_3/Concepts/partition_traits.h
View File

@ -21,73 +21,73 @@ public:
/*!
* A vertex descriptor corresponds to a unique vertex in an abstract partition instance.
*/
typedef unspecified_type Vertex_descriptor;
typedef unspecified_type vertex_descriptor;
/*!
* An edge descriptor corresponds to a unique edge in an abstract partition instance.
*/
typedef unspecified_type Edge_descriptor;
typedef unspecified_type edge_descriptor;
/*!
* A cell descriptor corresponds to a unique edge in an abstract partition instance.
*/
typedef unspecified_type Cell_descriptor;
typedef unspecified_type cell_descriptor;
/*!
* A container for the two vertices of an edge.
* Must be a model of `RandomAccessContainer` whose `value_type` must be `Vertex_descriptor`.
* Must be a model of `RandomAccessContainer` whose `value_type` must be `vertex_descriptor`.
*/
typedef unspecified_type Vertices_incident_to_edge;
/*!
* A container for the cells incident to an edge.
* Must be a model of `ForwardRange` whose `value_type` must be `Cell_descriptor`.
* Must be a model of `ForwardRange` whose `value_type` must be `cell_descriptor`.
*/
typedef unspecified_type Cells_incident_to_edge;
/*!
* A container for the vertices of a cell.
* Must be a model of `ForwardRange` whose `value_type` must be `Vertex_descriptor`.
* Must be a model of `ForwardRange` whose `value_type` must be `vertex_descriptor`.
*/
typedef unspecified_type Cell_vertices;
/*!
* A container for the edges of a cell.
* Must be a model of `ForwardRange` whose `value_type` must be `Edge_descriptor`.
* Must be a model of `ForwardRange` whose `value_type` must be `edge_descriptor`.
*/
typedef unspecified_type Cell_edges;
/*!
* \returns the 3D position of the vertex `v`.
*/
static Point_3 point(const Vertex_descriptor& v, const IsosurfacingPartition_3& partition);
static Point_3 point(const vertex_descriptor& v, const IsosurfacingPartition_3& partition);
/*!
* \returns the two vertices incident to the edge `e`.
*/
static Vertices_incident_to_edge incident_vertices(const Edge_descriptor& e, const IsosurfacingPartition_3& partition);
static Vertices_incident_to_edge incident_vertices(const edge_descriptor& e, const IsosurfacingPartition_3& partition);
/*!
* \returns all the cells incident to the edge `e`, in a geometrically ordered manner around the edge.
*/
static Cells_incident_to_edge incident_cells(const Edge_descriptor& e, const IsosurfacingPartition_3& partition);
static Cells_incident_to_edge incident_cells(const edge_descriptor& e, const IsosurfacingPartition_3& partition);
/*!
* \returns all the vertices of the cell `c`.
*/
static Cell_vertices cell_vertices(const Cell_descriptor& c, const IsosurfacingPartition_3& partition);
static Cell_vertices cell_vertices(const cell_descriptor& c, const IsosurfacingPartition_3& partition);
/*!
* \returns all the edges of the cell `c`.
*/
static Cell_edges cell_edges(const Cell_descriptor& c, const IsosurfacingPartition_3& partition);
static Cell_edges cell_edges(const cell_descriptor& c, const IsosurfacingPartition_3& partition);
/*!
* iterates over all vertices, and calls the functor `f` on each one.
*
* \tparam ConcurrencyTag decides if the vertices are iterated sequentially or in parallel.
* Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
* \tparam Functor must implement `void operator()(const Vertex_descriptor& vertex)`
* \tparam Functor must implement `void operator()(const vertex_descriptor& vertex)`
*
* \param f the functor called on every vertex
* \param partition the partition whose vertices are being iterated
@ -100,7 +100,7 @@ public:
*
* \tparam ConcurrencyTag decides if the edges are iterated sequentially or in parallel.
* Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
* \tparam Functor must implement `void operator()(const Edge_descriptor& edge)`.
* \tparam Functor must implement `void operator()(const edge_descriptor& edge)`.
*
* \param f the functor called on every edge
* \param partition the partition whose edges are being iterated
@ -113,7 +113,7 @@ public:
*
* \tparam ConcurrencyTag decides if the cells are iterated sequentially or in parallel.
* Can be either `CGAL::Sequential_tag`, `CGAL::Parallel_if_available_tag`, or `CGAL::Parallel_tag`.
* \tparam Functor must implement `void operator()(const Cell_descriptor& cell)`.
* \tparam Functor must implement `void operator()(const cell_descriptor& cell)`.
*
* \param f the functor called on every cell
* \param partition the partition whose cells are being iterated

4
Isosurfacing_3/include/CGAL/Isosurfacing_3/Gradient_function_3.h
View File

@ -43,7 +43,7 @@ public:
using Vector_3 = typename Geom_traits::Vector_3;
using PT = partition_traits<Partition>;
using Vertex_descriptor = typename PT::Vertex_descriptor;
using vertex_descriptor = typename PT::vertex_descriptor;
private:
std::function<Vector_3(const Point_3&)> m_fn;
@ -78,7 +78,7 @@ public:
/**
* \brief evaluates the function at the vertex `v`.
*/
const Vector_3& operator()(const Vertex_descriptor& v) const
const Vector_3& operator()(const vertex_descriptor& v) const
{
return this->operator()(PT::point(v, m_partition));
}

2
Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_gradients_3.h
View File

@ -43,7 +43,7 @@ class Interpolated_discrete_gradients_3
using Point_3 = typename Geom_traits::Point_3;
using Vector_3 = typename Geom_traits::Vector_3;
using Vertex_descriptor = typename partition_traits<Grid>::Vertex_descriptor;
using vertex_descriptor = typename partition_traits<Grid>::vertex_descriptor;
private:
const Grid& m_grid;

4
Isosurfacing_3/include/CGAL/Isosurfacing_3/Interpolated_discrete_values_3.h
View File

@ -43,7 +43,7 @@ class Interpolated_discrete_values_3
using FT = typename Geom_traits::FT;
using Point_3 = typename Geom_traits::Point_3;
using Vertex_descriptor = typename partition_traits<Grid>::Vertex_descriptor;
using vertex_descriptor = typename partition_traits<Grid>::vertex_descriptor;
private:
const Grid& m_grid;
@ -102,7 +102,7 @@ public:
/*!
* returns the value at vertex `v`.
*/
FT operator()(const Vertex_descriptor& v) const
FT operator()(const vertex_descriptor& v) const
{
return this->operator()(v[0], v[1], v[2]);
}

4
Isosurfacing_3/include/CGAL/Isosurfacing_3/Value_function_3.h
View File

@ -44,7 +44,7 @@ public:
using Point_3 = typename Geom_traits::Point_3;
using PT = partition_traits<Partition>;
using Vertex_descriptor = typename PT::Vertex_descriptor;
using vertex_descriptor = typename PT::vertex_descriptor;
private:
std::function<FT(const Point_3&)> m_fn;
@ -79,7 +79,7 @@ public:
/**
* \brief evaluates the function at the vertex `v`
*/
FT operator()(const Vertex_descriptor& v) const
FT operator()(const vertex_descriptor& v) const
{
return this->operator()(PT::point(v, m_partition));
}

2
Isosurfacing_3/include/CGAL/Isosurfacing_3/edge_intersection_oracles_3.h
View File

@ -188,7 +188,7 @@ struct Linear_interpolation_edge_intersection
struct Ray_marching_edge_intersection
{
template <typename Domain>
bool operator()(const typename Domain::Edge_descriptor& e,
bool operator()(const typename Domain::edge_descriptor& e,
const Domain& domain,
const typename Domain::Geom_traits::FT isovalue,
typename Domain::Geom_traits::Point_3& p) const

18
Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/Isosurfacing_domain_3.h
View File

@ -46,9 +46,9 @@ public:
using PT = CGAL::Isosurfacing::partition_traits<Partition>;
using Vertex_descriptor = typename PT::Vertex_descriptor;
using Edge_descriptor = typename PT::Edge_descriptor;
using Cell_descriptor = typename PT::Cell_descriptor;
using vertex_descriptor = typename PT::vertex_descriptor;
using edge_descriptor = typename PT::edge_descriptor;
using cell_descriptor = typename PT::cell_descriptor;
using Vertices_incident_to_edge = typename PT::Vertices_incident_to_edge;
using Cells_incident_to_edge = typename PT::Cells_incident_to_edge;
@ -90,13 +90,13 @@ public:
// The following functions are dispatching to the partition_traits' static functions.
// returns the position of vertex `v`
decltype(auto) /*Point_3*/ point(const Vertex_descriptor& v) const
decltype(auto) /*Point_3*/ point(const vertex_descriptor& v) const
{
return PT::point(v, m_partition);
}
// returns the value of the function at vertex `v`
decltype(auto) /*FT*/ value(const Vertex_descriptor& v) const
decltype(auto) /*FT*/ value(const vertex_descriptor& v) const
{
return m_values(v);
}
@ -114,25 +114,25 @@ public:
}
// returns a container with the two vertices incident to the edge `e`
decltype(auto) /*Vertices_incident_to_edge*/ incident_vertices(const Edge_descriptor& e) const
decltype(auto) /*Vertices_incident_to_edge*/ incident_vertices(const edge_descriptor& e) const
{
return PT::incident_vertices(e, m_partition);
}
// returns a container with all cells incident to the edge `e`
decltype(auto) /*Cells_incident_to_edge*/ incident_cells(const Edge_descriptor& e) const
decltype(auto) /*Cells_incident_to_edge*/ incident_cells(const edge_descriptor& e) const
{
return PT::incident_cells(e, m_partition);
}
// returns a container with all vertices of the cell `c`
decltype(auto) /*Cell_vertices*/ cell_vertices(const Cell_descriptor& c) const
decltype(auto) /*Cell_vertices*/ cell_vertices(const cell_descriptor& c) const
{
return PT::cell_vertices(c, m_partition);
}
// returns a container with all edges of the cell `c`
decltype(auto) /*Cell_edges*/ cell_edges(const Cell_descriptor& c) const
decltype(auto) /*Cell_edges*/ cell_edges(const cell_descriptor& c) const
{
return PT::cell_edges(c, m_partition);
}

76
Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/dual_contouring_functors.h
View File

@ -48,7 +48,7 @@ template <typename Domain,
typename EdgeToPointIDMap,
typename PointRange,
typename GradientRange>
bool cell_position_QEM(const typename Domain::Cell_descriptor& c,
bool cell_position_QEM(const typename Domain::cell_descriptor& c,
const Domain& domain,
const bool constrain_to_cell,
const EdgeToPointIDMap& edge_to_point_id,
@ -203,7 +203,7 @@ template <typename Domain,
typename EdgeToPointIDMap,
typename CellToPointIDMap,
typename PolygonRange>
void generate_face(const typename Domain::Edge_descriptor& e,
void generate_face(const typename Domain::edge_descriptor& e,
const Domain& domain,
const typename Domain::Geom_traits::FT isovalue,
const bool do_not_triangulate_faces,
@ -214,7 +214,7 @@ void generate_face(const typename Domain::Edge_descriptor& e,
{
using FT = typename Domain::Geom_traits::FT;
using Cell_descriptor = typename Domain::Cell_descriptor;
using cell_descriptor = typename Domain::cell_descriptor;
const auto& vertices = domain.incident_vertices(e);
@ -227,7 +227,7 @@ void generate_face(const typename Domain::Edge_descriptor& e,
std::vector<std::size_t> vertex_ids;
const auto& icells = domain.incident_cells(e);
for(const Cell_descriptor& c : icells)
for(const cell_descriptor& c : icells)
{
auto it = cell_to_point_id.find(c);
if(it == cell_to_point_id.end())
@ -293,9 +293,9 @@ class Dual_contourer<ConcurrencyTag, Domain, DC_Strategy::QEM>
using Point_3 = typename Geom_traits::Point_3;
using Vector_3 = typename Geom_traits::Vector_3;
using Vertex_descriptor = typename Domain::Vertex_descriptor;
using Edge_descriptor = typename Domain::Edge_descriptor;
using Cell_descriptor = typename Domain::Cell_descriptor;
using vertex_descriptor = typename Domain::vertex_descriptor;
using edge_descriptor = typename Domain::edge_descriptor;
using cell_descriptor = typename Domain::cell_descriptor;
std::mutex m_mutex;
@ -319,8 +319,8 @@ public:
const bool do_not_triangulate_faces =
choose_parameter(get_parameter(np, internal_np::do_not_triangulate_faces), false);
using Edge_to_point_ID_map = std::unordered_map<Edge_descriptor, std::size_t>;
using Cell_to_point_ID_map = std::unordered_map<Cell_descriptor, std::size_t>;
using Edge_to_point_ID_map = std::unordered_map<edge_descriptor, std::size_t>;
using Cell_to_point_ID_map = std::unordered_map<cell_descriptor, std::size_t>;
Edge_to_point_ID_map edge_to_point_id;
Cell_to_point_ID_map cell_to_point_id;
@ -330,11 +330,11 @@ public:
// ---------------------------------------------------------------------------------------------
// construct the intersection of the surface at active edges
auto edge_positioner = [&](const Edge_descriptor& e)
auto edge_positioner = [&](const edge_descriptor& e)
{
const auto& evs = domain.incident_vertices(e);
const Vertex_descriptor& v0 = evs[0];
const Vertex_descriptor& v1 = evs[1];
const vertex_descriptor& v0 = evs[0];
const vertex_descriptor& v1 = evs[1];
const Point_3& p0 = domain.point(v0);
const Point_3& p1 = domain.point(v1);
const FT val0 = domain.value(v0);
@ -362,10 +362,10 @@ public:
std::ofstream out_active_edges("active_edges.polylines");
for(const auto& ei : edge_to_point_id)
{
const Edge_descriptor& e = ei.first;
const edge_descriptor& e = ei.first;
const auto& evs = domain.incident_vertices(e);
const Vertex_descriptor& v0 = evs[0];
const Vertex_descriptor& v1 = evs[1];
const vertex_descriptor& v0 = evs[0];
const vertex_descriptor& v1 = evs[1];
const Point_3& p0 = domain.point(v0);
const Point_3& p1 = domain.point(v1);
@ -387,7 +387,7 @@ public:
// ---------------------------------------------------------------------------------------------
// create a vertex for each cell that has at least one active edge
auto cell_positioner = [&](const Cell_descriptor& c)
auto cell_positioner = [&](const cell_descriptor& c)
{
Point_3 p;
if(cell_position_QEM(c, domain, constrain_to_cell, edge_to_point_id,
@ -402,7 +402,7 @@ public:
// ---------------------------------------------------------------------------------------------
// connect vertices around edges to form faces
auto face_generator = [&](const Edge_descriptor& e)
auto face_generator = [&](const edge_descriptor& e)
{
generate_face(e, domain, isovalue, do_not_triangulate_faces,
edge_to_point_id, cell_to_point_id, m_mutex, polygons);
@ -425,9 +425,9 @@ class Dual_contourer<ConcurrencyTag, Domain, DC_Strategy::Centroid_of_edge_inter
using Point_3 = typename Geom_traits::Point_3;
using Vector_3 = typename Geom_traits::Vector_3;
using Vertex_descriptor = typename Domain::Vertex_descriptor;
using Edge_descriptor = typename Domain::Edge_descriptor;
using Cell_descriptor = typename Domain::Cell_descriptor;
using vertex_descriptor = typename Domain::vertex_descriptor;
using edge_descriptor = typename Domain::edge_descriptor;
using cell_descriptor = typename Domain::cell_descriptor;
std::mutex m_mutex;
@ -449,8 +449,8 @@ public:
bool do_not_triangulate_faces =
choose_parameter(get_parameter(np, internal_np::do_not_triangulate_faces), false);
using Edge_to_point_ID_map = std::unordered_map<Edge_descriptor, std::size_t>;
using Cell_to_point_ID_map = std::unordered_map<Cell_descriptor, std::size_t>;
using Edge_to_point_ID_map = std::unordered_map<edge_descriptor, std::size_t>;
using Cell_to_point_ID_map = std::unordered_map<cell_descriptor, std::size_t>;
Edge_to_point_ID_map edge_to_point_id;
Cell_to_point_ID_map cell_to_point_id;
@ -458,11 +458,11 @@ public:
std::vector<Point_3> edge_points;
// ---------------------------------------------------------------------------------------------
auto edge_positioner = [&](const Edge_descriptor& e)
auto edge_positioner = [&](const edge_descriptor& e)
{
const auto& evs = domain.incident_vertices(e);
const Vertex_descriptor& v0 = evs[0];
const Vertex_descriptor& v1 = evs[1];
const vertex_descriptor& v0 = evs[0];
const vertex_descriptor& v1 = evs[1];
const Point_3& p0 = domain.point(v0);
const Point_3& p1 = domain.point(v1);
const FT val0 = domain.value(v0);
@ -483,7 +483,7 @@ public:
points.insert(points.end(), edge_points.begin(), edge_points.end());
// ---------------------------------------------------------------------------------------------
auto cell_positioner = [&](const Cell_descriptor& c)
auto cell_positioner = [&](const cell_descriptor& c)
{
typename Geom_traits::Compute_x_3 x_coord = domain.geom_traits().compute_x_3_object();
typename Geom_traits::Compute_y_3 y_coord = domain.geom_traits().compute_y_3_object();
@ -492,7 +492,7 @@ public:
// compute edge intersections
std::vector<Point_3> edge_intersections;
for(const Edge_descriptor& e : domain.cell_edges(c))
for(const edge_descriptor& e : domain.cell_edges(c))
{
const auto it = edge_to_point_id.find(e);
if(it == edge_to_point_id.end())
@ -522,7 +522,7 @@ public:
domain.template for_each_cell<ConcurrencyTag>(cell_positioner);
// ---------------------------------------------------------------------------------------------
auto face_generator = [&](const Edge_descriptor& e)
auto face_generator = [&](const edge_descriptor& e)
{
generate_face(e, domain, isovalue, do_not_triangulate_faces,
edge_to_point_id, cell_to_point_id, m_mutex, polygons);
@ -540,9 +540,9 @@ class Dual_contourer<ConcurrencyTag, Domain, DC_Strategy::Cell_center>
using Point_3 = typename Geom_traits::Point_3;
using Vector_3 = typename Geom_traits::Vector_3;
using Vertex_descriptor = typename Domain::Vertex_descriptor;
using Edge_descriptor = typename Domain::Edge_descriptor;
using Cell_descriptor = typename Domain::Cell_descriptor;
using vertex_descriptor = typename Domain::vertex_descriptor;
using edge_descriptor = typename Domain::edge_descriptor;
using cell_descriptor = typename Domain::cell_descriptor;
std::mutex m_mutex;
@ -564,8 +564,8 @@ public:
bool do_not_triangulate_faces =
choose_parameter(get_parameter(np, internal_np::do_not_triangulate_faces), false);
using Edge_to_point_ID_map = std::unordered_map<Edge_descriptor, std::size_t>;
using Cell_to_point_ID_map = std::unordered_map<Cell_descriptor, std::size_t>;
using Edge_to_point_ID_map = std::unordered_map<edge_descriptor, std::size_t>;
using Cell_to_point_ID_map = std::unordered_map<cell_descriptor, std::size_t>;
Edge_to_point_ID_map edge_to_point_id;
Cell_to_point_ID_map cell_to_point_id;
@ -573,7 +573,7 @@ public:
std::vector<Point_3> edge_points;
// ---------------------------------------------------------------------------------------------
auto edge_positioner = [&](const Edge_descriptor& e)
auto edge_positioner = [&](const edge_descriptor& e)
{
typename Geom_traits::Compute_x_3 x_coord = domain.geom_traits().compute_x_3_object();
typename Geom_traits::Compute_y_3 y_coord = domain.geom_traits().compute_y_3_object();
@ -581,8 +581,8 @@ public:
typename Geom_traits::Construct_point_3 point = domain.geom_traits().construct_point_3_object();
const auto& evs = domain.incident_vertices(e);
const Vertex_descriptor& v0 = evs[0];
const Vertex_descriptor& v1 = evs[1];
const vertex_descriptor& v0 = evs[0];
const vertex_descriptor& v1 = evs[1];
const FT val_0 = domain.value(v0);
const FT val_1 = domain.value(v1);
@ -603,7 +603,7 @@ public:
points.insert(points.end(), edge_points.begin(), edge_points.end());
// ---------------------------------------------------------------------------------------------
auto cell_positioner = [&](const Cell_descriptor& c)
auto cell_positioner = [&](const cell_descriptor& c)
{
typename Geom_traits::Compute_x_3 x_coord = domain.geom_traits().compute_x_3_object();
typename Geom_traits::Compute_y_3 y_coord = domain.geom_traits().compute_y_3_object();
@ -644,7 +644,7 @@ public:
domain.template for_each_cell<ConcurrencyTag>(cell_positioner);
// ---------------------------------------------------------------------------------------------
auto face_generator = [&](const Edge_descriptor& e)
auto face_generator = [&](const edge_descriptor& e)
{
generate_face(e, domain, isovalue, do_not_triangulate_faces,
edge_to_point_id, cell_to_point_id, m_mutex, polygons);

18
Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/marching_cubes_functors.h
View File

@ -103,19 +103,19 @@ template <typename Domain,
typename Corners,
typename Values>
std::size_t get_cell_corners(const Domain& domain,
const typename Domain::Cell_descriptor& cell,
const typename Domain::cell_descriptor& cell,
const typename Domain::Geom_traits::FT isovalue,
Corners& corners,
Values& values)
{
using Vertex_descriptor = typename Domain::Vertex_descriptor;
using vertex_descriptor = typename Domain::vertex_descriptor;
const auto& vertices = domain.cell_vertices(cell);
// collect function values and build index
std::size_t v_id = 0;
std::bitset<Domain::VERTICES_PER_CELL> index = 0;
for(const Vertex_descriptor& v : vertices)
for(const vertex_descriptor& v : vertices)
{
values[v_id] = domain.value(v);
if(values[v_id] >= isovalue)
@ -128,7 +128,7 @@ std::size_t get_cell_corners(const Domain& domain,
return static_cast<std::size_t>(index.to_ullong());
v_id = 0;
for(const Vertex_descriptor& v : vertices)
for(const vertex_descriptor& v : vertices)
corners[v_id++] = domain.point(v);
return static_cast<std::size_t>(index.to_ullong());
@ -139,7 +139,7 @@ template <typename Corners,
typename Values,
typename Domain,
typename Vertices>
void MC_construct_vertices(const typename Domain::Cell_descriptor& cell,
void MC_construct_vertices(const typename Domain::cell_descriptor& cell,
const std::size_t i_case,
const Corners& corners,
const Values& values,
@ -148,7 +148,7 @@ void MC_construct_vertices(const typename Domain::Cell_descriptor& cell,
Vertices& vertices)
{
using Cell_edges = typename Domain::Cell_edges;
using Edge_descriptor = typename Domain::Edge_descriptor;
using edge_descriptor = typename Domain::edge_descriptor;
const Cell_edges& cell_edges = domain.cell_edges(cell);
@ -156,7 +156,7 @@ void MC_construct_vertices(const typename Domain::Cell_descriptor& cell,
std::size_t flag = 1;
std::size_t e_id = 0;
for(const Edge_descriptor& e : cell_edges)
for(const edge_descriptor& e : cell_edges)
{
CGAL_USE(e);
@ -253,7 +253,7 @@ public:
using FT = typename Geom_traits::FT;
using Point_3 = typename Geom_traits::Point_3;
using Cell_descriptor = typename Domain::Cell_descriptor;
using cell_descriptor = typename Domain::cell_descriptor;
#ifdef CGAL_LINKED_WITH_TBB
using Triangles = tbb::enumerable_thread_specific<std::vector<std::array<Point_3, 3>>>;
@ -283,7 +283,7 @@ public:
public:
// computes one cell
void operator()(const Cell_descriptor& cell)
void operator()(const cell_descriptor& cell)
{
CGAL_precondition(m_domain.cell_vertices(cell).size() == 8);
CGAL_precondition(m_domain.cell_edges(cell).size() == 12);

24
Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Cartesian_grid.h
View File

@ -48,31 +48,31 @@ struct partition_traits<Cartesian_grid_3<GeomTraits, MemoryPolicy> >
using Grid = Cartesian_grid_3<GeomTraits, MemoryPolicy>;
// identifies a vertex by its (i, j, k) indices
using Vertex_descriptor = std::array<std::size_t, 3>;
using vertex_descriptor = std::array<std::size_t, 3>;
// identifies an edge by its starting vertex (i, j, k) and the direction x -> 0, y -> 1, z -> 2
using Edge_descriptor = CG_Edge_descriptor;
using edge_descriptor = CG_Edge_descriptor;
// identifies a cell by its corner vertex with the smallest (i, j, k) index
using Cell_descriptor = CG_Cell_descriptor;
using cell_descriptor = CG_Cell_descriptor;
static constexpr Cell_type CELL_TYPE = CUBICAL_CELL;
static constexpr std::size_t VERTICES_PER_CELL = 8;
static constexpr std::size_t EDGES_PER_CELL = 12;
using Vertices_incident_to_edge = std::array<Vertex_descriptor, 2>;
using Cells_incident_to_edge = std::array<Cell_descriptor, 4>;
using Cell_vertices = std::array<Vertex_descriptor, VERTICES_PER_CELL>;
using Cell_edges = std::array<Edge_descriptor, EDGES_PER_CELL>;
using Vertices_incident_to_edge = std::array<vertex_descriptor, 2>;
using Cells_incident_to_edge = std::array<cell_descriptor, 4>;
using Cell_vertices = std::array<vertex_descriptor, VERTICES_PER_CELL>;
using Cell_edges = std::array<edge_descriptor, EDGES_PER_CELL>;
static decltype(auto) /*Point_3*/ point(const Vertex_descriptor& v,
static decltype(auto) /*Point_3*/ point(const vertex_descriptor& v,
const Grid& g)
{
return g.point(v[0], v[1], v[2]);
}
// returns a container with the two vertices incident to edge e
static Vertices_incident_to_edge incident_vertices(const Edge_descriptor& e,
static Vertices_incident_to_edge incident_vertices(const edge_descriptor& e,
const Grid&)
{
Vertices_incident_to_edge ev;
@ -83,7 +83,7 @@ struct partition_traits<Cartesian_grid_3<GeomTraits, MemoryPolicy> >
}
// returns a container with all cells incident to edge e
static Cells_incident_to_edge incident_cells(const Edge_descriptor& e,
static Cells_incident_to_edge incident_cells(const edge_descriptor& e,
const Grid&)
{
// lookup the neighbor cells relative to the edge
@ -103,7 +103,7 @@ struct partition_traits<Cartesian_grid_3<GeomTraits, MemoryPolicy> >
}
// returns a container with all vertices of cell c
static Cell_vertices cell_vertices(const Cell_descriptor& c,
static Cell_vertices cell_vertices(const cell_descriptor& c,
const Grid&)
{
Cell_vertices cv;
@ -119,7 +119,7 @@ struct partition_traits<Cartesian_grid_3<GeomTraits, MemoryPolicy> >
}
// returns a container with all edges of cell c
static Cell_edges cell_edges(const Cell_descriptor& c,
static Cell_edges cell_edges(const cell_descriptor& c,
const Grid&)
{
Cell_edges ce;

30
Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/partition_traits_Octree.h
View File

@ -44,45 +44,45 @@ struct partition_traits<internal::Octree_wrapper<GeomTraits> >
using Octree = internal::Octree_wrapper<GeomTraits>;
public:
using Vertex_descriptor = typename Octree::Vertex_handle;
using Edge_descriptor = typename Octree::Edge_handle;
using Cell_descriptor = typename Octree::Voxel_handle;
using vertex_descriptor = typename Octree::Vertex_handle;
using edge_descriptor = typename Octree::Edge_handle;
using cell_descriptor = typename Octree::Voxel_handle;
static constexpr Cell_type CELL_TYPE = CUBICAL_CELL;
static constexpr std::size_t VERTICES_PER_CELL = 8;
static constexpr std::size_t EDGES_PER_CELL = 12;
using Vertices_incident_to_edge = std::array<Vertex_descriptor, 2>;
using Cells_incident_to_edge = std::array<Cell_descriptor, 4>; // @todo: not always 4
using Cell_vertices = std::array<Vertex_descriptor, 8>;
using Cell_edges = std::array<Edge_descriptor, 12>;
using Vertices_incident_to_edge = std::array<vertex_descriptor, 2>;
using Cells_incident_to_edge = std::array<cell_descriptor, 4>; // @todo: not always 4
using Cell_vertices = std::array<vertex_descriptor, 8>;
using Cell_edges = std::array<edge_descriptor, 12>;
public:
static decltype(auto) /*Point_3*/ point(const Vertex_descriptor& v,
static decltype(auto) /*Point_3*/ point(const vertex_descriptor& v,
const Octree& o)
{
return o.point(v);
}
static Vertices_incident_to_edge incident_vertices(const Edge_descriptor& e,
static Vertices_incident_to_edge incident_vertices(const edge_descriptor& e,
const Octree& o)
{
return o.edge_vertices(e);
}
static Cells_incident_to_edge incident_cells(const Edge_descriptor& e,
static Cells_incident_to_edge incident_cells(const edge_descriptor& e,
const Octree& o)
{
return o.edge_voxels(e);
}
static Cell_vertices cell_vertices(const Cell_descriptor& c,
static Cell_vertices cell_vertices(const cell_descriptor& c,
const Octree& o)
{
return o.voxel_vertices(c);
}
static Cell_edges cell_edges(const Cell_descriptor& c,
static Cell_edges cell_edges(const cell_descriptor& c,
const Octree& o)
{
return o.voxel_edges(c);
@ -93,7 +93,7 @@ public:
const Octree& o,
const CGAL::Sequential_tag)
{
for(const Vertex_descriptor& v : o.leaf_vertices())
for(const vertex_descriptor& v : o.leaf_vertices())
f(v);
}
@ -102,7 +102,7 @@ public:
const Octree& o,
Sequential_tag)
{
for(const Edge_descriptor& e : o.leaf_edges())
for(const edge_descriptor& e : o.leaf_edges())
f(e);
}
@ -111,7 +111,7 @@ public:
const Octree& o,
CGAL::Sequential_tag)
{
for(const Cell_descriptor& v : o.leaf_voxels())
for(const cell_descriptor& v : o.leaf_voxels())
f(v);
}

10
Isosurfacing_3/include/CGAL/Isosurfacing_3/internal/topologically_correct_marching_cubes_functors.h
View File

@ -72,8 +72,8 @@ private:
using FT = typename Geom_traits::FT;
using Point_3 = typename Geom_traits::Point_3;
using Edge_descriptor = typename Domain::Edge_descriptor;
using Cell_descriptor = typename Domain::Cell_descriptor;
using edge_descriptor = typename Domain::edge_descriptor;
using cell_descriptor = typename Domain::cell_descriptor;
using Point_index = std::size_t;
using Edge_index = std::array<std::size_t, 4>;
@ -140,7 +140,7 @@ public:
m_point_counter(0)
{ }
void operator()(const Cell_descriptor& cell)
void operator()(const cell_descriptor& cell)
{
std::array<FT, 8> values;
std::array<Point_3, 8> corners;
@ -206,7 +206,7 @@ public:
}
private:
Edge_index compute_edge_index(const Cell_descriptor& cell, int edge)
Edge_index compute_edge_index(const cell_descriptor& cell, int edge)
{
// edge is in 0 - 11
@ -293,7 +293,7 @@ private:
m_triangles.push_back({p0, p1, p2});
}
bool p_slice(const Cell_descriptor& cell,
bool p_slice(const cell_descriptor& cell,
const FT i0,
const std::array<Point_3, 8>& corners,
const std::array<FT, 8>& values,

18
Isosurfacing_3/test/Isosurfacing_3/test_isosurfacing_concepts.cpp
View File

@ -73,9 +73,9 @@ struct MC_Domain
typedef Traits<K> Geom_traits;
typedef typename Geom_traits::FT FT;
typedef typename Geom_traits::Point_3 Point_3;
typedef std::size_t Vertex_descriptor;
typedef std::size_t Edge_descriptor;
typedef std::size_t Cell_descriptor;
typedef std::size_t vertex_descriptor;
typedef std::size_t edge_descriptor;
typedef std::size_t cell_descriptor;
typedef std::vector<std::size_t> Vertices_incident_to_edge;
typedef std::vector<std::size_t> Cells_incident_to_edge;
typedef std::vector<std::size_t> Cell_vertices;
@ -83,15 +83,15 @@ struct MC_Domain
Geom_traits geom_traits() const { return Geom_traits(); }
Point_3 point(const Vertex_descriptor& /*v*/) const { return CGAL::ORIGIN; }
Point_3 point(const vertex_descriptor& /*v*/) const { return CGAL::ORIGIN; }
FT value(const Point_3& /*p*/) const { return 0; }
FT value(const Vertex_descriptor& /*v*/) const { return 0; }
FT value(const vertex_descriptor& /*v*/) const { return 0; }
Vertices_incident_to_edge incident_vertices(const Edge_descriptor& /*e*/) const { return {}; }
Cells_incident_to_edge incident_cells(const Edge_descriptor& /*e*/) const { return {}; }
Cell_vertices cell_vertices(const Cell_descriptor& /*c*/) const { return {}; }
Cell_edges cell_edges(const Cell_descriptor& /*c*/) const { return {}; }
Vertices_incident_to_edge incident_vertices(const edge_descriptor& /*e*/) const { return {}; }
Cells_incident_to_edge incident_cells(const edge_descriptor& /*e*/) const { return {}; }
Cell_vertices cell_vertices(const cell_descriptor& /*c*/) const { return {}; }
Cell_edges cell_edges(const cell_descriptor& /*c*/) const { return {}; }
template <typename ConcurrencyTag, typename Functor>
void for_each_vertex(Functor& /*f*/) const { }