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. A descriptor that uniquely identifies a vertex.
Must be a model of the concepts `DefaultConstructible`, `CopyConstructible`, and `Assignable`. 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. A descriptor that uniquely identifies an edge.
Must be a model of the concepts `DefaultConstructible`, `CopyConstructible`, and `Assignable`. 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. A descriptor that uniquely identifies a cell.
Must be a model of the concepts `DefaultConstructible`, `CopyConstructible`, and `Assignable`. 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. 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; typedef unspecified_type Vertices_incident_to_edge;
/*! /*!
A container for the cells incident to an 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; typedef unspecified_type Cells_incident_to_edge;
/*! /*!
A container for the vertices of a cell. 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; typedef unspecified_type Cell_vertices;
/*! /*!
A container for the edges of a cell. 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; typedef unspecified_type Cell_edges;
@ -97,7 +97,7 @@ public:
/*! /*!
returns the 3D position of the vertex `v`. 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`. 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`. 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`. 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. 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`. 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`. 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. iterates over all vertices, and calls the functor `f` on each one.
\tparam ConcurrencyTag decides if the vertices are iterated sequentially or in parallel. \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`. 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 f the functor called on every vertex
*/ */
@ -146,7 +146,7 @@ public:
\tparam ConcurrencyTag decides if the edges are iterated sequentially or in parallel. \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`. 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 f the functor called on every edge
*/ */
@ -158,7 +158,7 @@ public:
\tparam ConcurrencyTag decides if the cells are iterated sequentially or in parallel. \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`. 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 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`). * 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`. 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`. 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. * 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. * 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. * 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. * 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; typedef unspecified_type Vertices_incident_to_edge;
/*! /*!
* A container for the cells incident to an 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; typedef unspecified_type Cells_incident_to_edge;
/*! /*!
* A container for the vertices of a cell. * 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; typedef unspecified_type Cell_vertices;
/*! /*!
* A container for the edges of a cell. * 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; typedef unspecified_type Cell_edges;
/*! /*!
* \returns the 3D position of the vertex `v`. * \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`. * \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. * \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`. * \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`. * \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. * iterates over all vertices, and calls the functor `f` on each one.
* *
* \tparam ConcurrencyTag decides if the vertices are iterated sequentially or in parallel. * \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`. * 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 f the functor called on every vertex
* \param partition the partition whose vertices are being iterated * \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. * \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`. * 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 f the functor called on every edge
* \param partition the partition whose edges are being iterated * \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. * \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`. * 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 f the functor called on every cell
* \param partition the partition whose cells are being iterated * \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 Vector_3 = typename Geom_traits::Vector_3;
using PT = partition_traits<Partition>; using PT = partition_traits<Partition>;
using Vertex_descriptor = typename PT::Vertex_descriptor; using vertex_descriptor = typename PT::vertex_descriptor;
private: private:
std::function<Vector_3(const Point_3&)> m_fn; std::function<Vector_3(const Point_3&)> m_fn;
@ -78,7 +78,7 @@ public:
/** /**
* \brief evaluates the function at the vertex `v`. * \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)); 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 Point_3 = typename Geom_traits::Point_3;
using Vector_3 = typename Geom_traits::Vector_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: private:
const Grid& m_grid; 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 FT = typename Geom_traits::FT;
using Point_3 = typename Geom_traits::Point_3; 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: private:
const Grid& m_grid; const Grid& m_grid;
@ -102,7 +102,7 @@ public:
/*! /*!
* returns the value at vertex `v`. * 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]); 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 Point_3 = typename Geom_traits::Point_3;
using PT = partition_traits<Partition>; using PT = partition_traits<Partition>;
using Vertex_descriptor = typename PT::Vertex_descriptor; using vertex_descriptor = typename PT::vertex_descriptor;
private: private:
std::function<FT(const Point_3&)> m_fn; std::function<FT(const Point_3&)> m_fn;
@ -79,7 +79,7 @@ public:
/** /**
* \brief evaluates the function at the vertex `v` * \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)); 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 struct Ray_marching_edge_intersection
{ {
template <typename Domain> template <typename Domain>
bool operator()(const typename Domain::Edge_descriptor& e, bool operator()(const typename Domain::edge_descriptor& e,
const Domain& domain, const Domain& domain,
const typename Domain::Geom_traits::FT isovalue, const typename Domain::Geom_traits::FT isovalue,
typename Domain::Geom_traits::Point_3& p) const 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 PT = CGAL::Isosurfacing::partition_traits<Partition>;
using Vertex_descriptor = typename PT::Vertex_descriptor; using vertex_descriptor = typename PT::vertex_descriptor;
using Edge_descriptor = typename PT::Edge_descriptor; using edge_descriptor = typename PT::edge_descriptor;
using Cell_descriptor = typename PT::Cell_descriptor; using cell_descriptor = typename PT::cell_descriptor;
using Vertices_incident_to_edge = typename PT::Vertices_incident_to_edge; using Vertices_incident_to_edge = typename PT::Vertices_incident_to_edge;
using Cells_incident_to_edge = typename PT::Cells_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. // The following functions are dispatching to the partition_traits' static functions.
// returns the position of vertex `v` // 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); return PT::point(v, m_partition);
} }
// returns the value of the function at vertex `v` // 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); return m_values(v);
} }
@ -114,25 +114,25 @@ public:
} }
// returns a container with the two vertices incident to the edge `e` // 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); return PT::incident_vertices(e, m_partition);
} }
// returns a container with all cells incident to the edge `e` // 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); return PT::incident_cells(e, m_partition);
} }
// returns a container with all vertices of the cell `c` // 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); return PT::cell_vertices(c, m_partition);
} }
// returns a container with all edges of the cell `c` // 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); 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 EdgeToPointIDMap,
typename PointRange, typename PointRange,
typename GradientRange> 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 Domain& domain,
const bool constrain_to_cell, const bool constrain_to_cell,
const EdgeToPointIDMap& edge_to_point_id, const EdgeToPointIDMap& edge_to_point_id,
@ -203,7 +203,7 @@ template <typename Domain,
typename EdgeToPointIDMap, typename EdgeToPointIDMap,
typename CellToPointIDMap, typename CellToPointIDMap,
typename PolygonRange> typename PolygonRange>
void generate_face(const typename Domain::Edge_descriptor& e, void generate_face(const typename Domain::edge_descriptor& e,
const Domain& domain, const Domain& domain,
const typename Domain::Geom_traits::FT isovalue, const typename Domain::Geom_traits::FT isovalue,
const bool do_not_triangulate_faces, 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 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); 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; std::vector<std::size_t> vertex_ids;
const auto& icells = domain.incident_cells(e); 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); auto it = cell_to_point_id.find(c);
if(it == cell_to_point_id.end()) 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 Point_3 = typename Geom_traits::Point_3;
using Vector_3 = typename Geom_traits::Vector_3; using Vector_3 = typename Geom_traits::Vector_3;
using Vertex_descriptor = typename Domain::Vertex_descriptor; using vertex_descriptor = typename Domain::vertex_descriptor;
using Edge_descriptor = typename Domain::Edge_descriptor; using edge_descriptor = typename Domain::edge_descriptor;
using Cell_descriptor = typename Domain::Cell_descriptor; using cell_descriptor = typename Domain::cell_descriptor;
std::mutex m_mutex; std::mutex m_mutex;
@ -319,8 +319,8 @@ public:
const bool do_not_triangulate_faces = const bool do_not_triangulate_faces =
choose_parameter(get_parameter(np, internal_np::do_not_triangulate_faces), false); 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 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 Cell_to_point_ID_map = std::unordered_map<cell_descriptor, std::size_t>;
Edge_to_point_ID_map edge_to_point_id; Edge_to_point_ID_map edge_to_point_id;
Cell_to_point_ID_map cell_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 // 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 auto& evs = domain.incident_vertices(e);
const Vertex_descriptor& v0 = evs[0]; const vertex_descriptor& v0 = evs[0];
const Vertex_descriptor& v1 = evs[1]; const vertex_descriptor& v1 = evs[1];
const Point_3& p0 = domain.point(v0); const Point_3& p0 = domain.point(v0);
const Point_3& p1 = domain.point(v1); const Point_3& p1 = domain.point(v1);
const FT val0 = domain.value(v0); const FT val0 = domain.value(v0);
@ -362,10 +362,10 @@ public:
std::ofstream out_active_edges("active_edges.polylines"); std::ofstream out_active_edges("active_edges.polylines");
for(const auto& ei : edge_to_point_id) 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 auto& evs = domain.incident_vertices(e);
const Vertex_descriptor& v0 = evs[0]; const vertex_descriptor& v0 = evs[0];
const Vertex_descriptor& v1 = evs[1]; const vertex_descriptor& v1 = evs[1];
const Point_3& p0 = domain.point(v0); const Point_3& p0 = domain.point(v0);
const Point_3& p1 = domain.point(v1); 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 // 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; Point_3 p;
if(cell_position_QEM(c, domain, constrain_to_cell, edge_to_point_id, 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 // 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, generate_face(e, domain, isovalue, do_not_triangulate_faces,
edge_to_point_id, cell_to_point_id, m_mutex, polygons); 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 Point_3 = typename Geom_traits::Point_3;
using Vector_3 = typename Geom_traits::Vector_3; using Vector_3 = typename Geom_traits::Vector_3;
using Vertex_descriptor = typename Domain::Vertex_descriptor; using vertex_descriptor = typename Domain::vertex_descriptor;
using Edge_descriptor = typename Domain::Edge_descriptor; using edge_descriptor = typename Domain::edge_descriptor;
using Cell_descriptor = typename Domain::Cell_descriptor; using cell_descriptor = typename Domain::cell_descriptor;
std::mutex m_mutex; std::mutex m_mutex;
@ -449,8 +449,8 @@ public:
bool do_not_triangulate_faces = bool do_not_triangulate_faces =
choose_parameter(get_parameter(np, internal_np::do_not_triangulate_faces), false); 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 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 Cell_to_point_ID_map = std::unordered_map<cell_descriptor, std::size_t>;
Edge_to_point_ID_map edge_to_point_id; Edge_to_point_ID_map edge_to_point_id;
Cell_to_point_ID_map cell_to_point_id; Cell_to_point_ID_map cell_to_point_id;
@ -458,11 +458,11 @@ public:
std::vector<Point_3> edge_points; 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 auto& evs = domain.incident_vertices(e);
const Vertex_descriptor& v0 = evs[0]; const vertex_descriptor& v0 = evs[0];
const Vertex_descriptor& v1 = evs[1]; const vertex_descriptor& v1 = evs[1];
const Point_3& p0 = domain.point(v0); const Point_3& p0 = domain.point(v0);
const Point_3& p1 = domain.point(v1); const Point_3& p1 = domain.point(v1);
const FT val0 = domain.value(v0); const FT val0 = domain.value(v0);
@ -483,7 +483,7 @@ public:
points.insert(points.end(), edge_points.begin(), edge_points.end()); 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_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(); typename Geom_traits::Compute_y_3 y_coord = domain.geom_traits().compute_y_3_object();
@ -492,7 +492,7 @@ public:
// compute edge intersections // compute edge intersections
std::vector<Point_3> 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); const auto it = edge_to_point_id.find(e);
if(it == edge_to_point_id.end()) if(it == edge_to_point_id.end())
@ -522,7 +522,7 @@ public:
domain.template for_each_cell<ConcurrencyTag>(cell_positioner); 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, generate_face(e, domain, isovalue, do_not_triangulate_faces,
edge_to_point_id, cell_to_point_id, m_mutex, polygons); 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 Point_3 = typename Geom_traits::Point_3;
using Vector_3 = typename Geom_traits::Vector_3; using Vector_3 = typename Geom_traits::Vector_3;
using Vertex_descriptor = typename Domain::Vertex_descriptor; using vertex_descriptor = typename Domain::vertex_descriptor;
using Edge_descriptor = typename Domain::Edge_descriptor; using edge_descriptor = typename Domain::edge_descriptor;
using Cell_descriptor = typename Domain::Cell_descriptor; using cell_descriptor = typename Domain::cell_descriptor;
std::mutex m_mutex; std::mutex m_mutex;
@ -564,8 +564,8 @@ public:
bool do_not_triangulate_faces = bool do_not_triangulate_faces =
choose_parameter(get_parameter(np, internal_np::do_not_triangulate_faces), false); 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 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 Cell_to_point_ID_map = std::unordered_map<cell_descriptor, std::size_t>;
Edge_to_point_ID_map edge_to_point_id; Edge_to_point_ID_map edge_to_point_id;
Cell_to_point_ID_map cell_to_point_id; Cell_to_point_ID_map cell_to_point_id;
@ -573,7 +573,7 @@ public:
std::vector<Point_3> edge_points; 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_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(); 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(); typename Geom_traits::Construct_point_3 point = domain.geom_traits().construct_point_3_object();
const auto& evs = domain.incident_vertices(e); const auto& evs = domain.incident_vertices(e);
const Vertex_descriptor& v0 = evs[0]; const vertex_descriptor& v0 = evs[0];
const Vertex_descriptor& v1 = evs[1]; const vertex_descriptor& v1 = evs[1];
const FT val_0 = domain.value(v0); const FT val_0 = domain.value(v0);
const FT val_1 = domain.value(v1); const FT val_1 = domain.value(v1);
@ -603,7 +603,7 @@ public:
points.insert(points.end(), edge_points.begin(), edge_points.end()); 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_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(); 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); 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, generate_face(e, domain, isovalue, do_not_triangulate_faces,
edge_to_point_id, cell_to_point_id, m_mutex, polygons); 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 Corners,
typename Values> typename Values>
std::size_t get_cell_corners(const Domain& domain, 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, const typename Domain::Geom_traits::FT isovalue,
Corners& corners, Corners& corners,
Values& values) Values& values)
{ {
using Vertex_descriptor = typename Domain::Vertex_descriptor; using vertex_descriptor = typename Domain::vertex_descriptor;
const auto& vertices = domain.cell_vertices(cell); const auto& vertices = domain.cell_vertices(cell);
// collect function values and build index // collect function values and build index
std::size_t v_id = 0; std::size_t v_id = 0;
std::bitset<Domain::VERTICES_PER_CELL> index = 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); values[v_id] = domain.value(v);
if(values[v_id] >= isovalue) 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()); return static_cast<std::size_t>(index.to_ullong());
v_id = 0; v_id = 0;
for(const Vertex_descriptor& v : vertices) for(const vertex_descriptor& v : vertices)
corners[v_id++] = domain.point(v); corners[v_id++] = domain.point(v);
return static_cast<std::size_t>(index.to_ullong()); return static_cast<std::size_t>(index.to_ullong());
@ -139,7 +139,7 @@ template <typename Corners,
typename Values, typename Values,
typename Domain, typename Domain,
typename Vertices> 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 std::size_t i_case,
const Corners& corners, const Corners& corners,
const Values& values, const Values& values,
@ -148,7 +148,7 @@ void MC_construct_vertices(const typename Domain::Cell_descriptor& cell,
Vertices& vertices) Vertices& vertices)
{ {
using Cell_edges = typename Domain::Cell_edges; 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); 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 flag = 1;
std::size_t e_id = 0; std::size_t e_id = 0;
for(const Edge_descriptor& e : cell_edges) for(const edge_descriptor& e : cell_edges)
{ {
CGAL_USE(e); CGAL_USE(e);
@ -253,7 +253,7 @@ public:
using FT = typename Geom_traits::FT; using FT = typename Geom_traits::FT;
using Point_3 = typename Geom_traits::Point_3; 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 #ifdef CGAL_LINKED_WITH_TBB
using Triangles = tbb::enumerable_thread_specific<std::vector<std::array<Point_3, 3>>>; using Triangles = tbb::enumerable_thread_specific<std::vector<std::array<Point_3, 3>>>;
@ -283,7 +283,7 @@ public:
public: public:
// computes one cell // 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_vertices(cell).size() == 8);
CGAL_precondition(m_domain.cell_edges(cell).size() == 12); 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>; using Grid = Cartesian_grid_3<GeomTraits, MemoryPolicy>;
// identifies a vertex by its (i, j, k) indices // 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 // 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 // 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 Cell_type CELL_TYPE = CUBICAL_CELL;
static constexpr std::size_t VERTICES_PER_CELL = 8; static constexpr std::size_t VERTICES_PER_CELL = 8;
static constexpr std::size_t EDGES_PER_CELL = 12; static constexpr std::size_t EDGES_PER_CELL = 12;
using Vertices_incident_to_edge = std::array<Vertex_descriptor, 2>; using Vertices_incident_to_edge = std::array<vertex_descriptor, 2>;
using Cells_incident_to_edge = std::array<Cell_descriptor, 4>; using Cells_incident_to_edge = std::array<cell_descriptor, 4>;
using Cell_vertices = std::array<Vertex_descriptor, VERTICES_PER_CELL>; using Cell_vertices = std::array<vertex_descriptor, VERTICES_PER_CELL>;
using Cell_edges = std::array<Edge_descriptor, EDGES_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) const Grid& g)
{ {
return g.point(v[0], v[1], v[2]); return g.point(v[0], v[1], v[2]);
} }
// returns a container with the two vertices incident to edge e // 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&) const Grid&)
{ {
Vertices_incident_to_edge ev; 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 // 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&) const Grid&)
{ {
// lookup the neighbor cells relative to the edge // 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 // 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&) const Grid&)
{ {
Cell_vertices cv; Cell_vertices cv;
@ -119,7 +119,7 @@ struct partition_traits<Cartesian_grid_3<GeomTraits, MemoryPolicy> >
} }
// returns a container with all edges of cell c // 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&) const Grid&)
{ {
Cell_edges ce; 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>; using Octree = internal::Octree_wrapper<GeomTraits>;
public: public:
using Vertex_descriptor = typename Octree::Vertex_handle; using vertex_descriptor = typename Octree::Vertex_handle;
using Edge_descriptor = typename Octree::Edge_handle; using edge_descriptor = typename Octree::Edge_handle;
using Cell_descriptor = typename Octree::Voxel_handle; using cell_descriptor = typename Octree::Voxel_handle;
static constexpr Cell_type CELL_TYPE = CUBICAL_CELL; static constexpr Cell_type CELL_TYPE = CUBICAL_CELL;
static constexpr std::size_t VERTICES_PER_CELL = 8; static constexpr std::size_t VERTICES_PER_CELL = 8;
static constexpr std::size_t EDGES_PER_CELL = 12; static constexpr std::size_t EDGES_PER_CELL = 12;
using Vertices_incident_to_edge = std::array<Vertex_descriptor, 2>; 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 Cells_incident_to_edge = std::array<cell_descriptor, 4>; // @todo: not always 4
using Cell_vertices = std::array<Vertex_descriptor, 8>; using Cell_vertices = std::array<vertex_descriptor, 8>;
using Cell_edges = std::array<Edge_descriptor, 12>; using Cell_edges = std::array<edge_descriptor, 12>;
public: public:
static decltype(auto) /*Point_3*/ point(const Vertex_descriptor& v, static decltype(auto) /*Point_3*/ point(const vertex_descriptor& v,
const Octree& o) const Octree& o)
{ {
return o.point(v); 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) const Octree& o)
{ {
return o.edge_vertices(e); 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) const Octree& o)
{ {
return o.edge_voxels(e); 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) const Octree& o)
{ {
return o.voxel_vertices(c); 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) const Octree& o)
{ {
return o.voxel_edges(c); return o.voxel_edges(c);
@ -93,7 +93,7 @@ public:
const Octree& o, const Octree& o,
const CGAL::Sequential_tag) const CGAL::Sequential_tag)
{ {
for(const Vertex_descriptor& v : o.leaf_vertices()) for(const vertex_descriptor& v : o.leaf_vertices())
f(v); f(v);
} }
@ -102,7 +102,7 @@ public:
const Octree& o, const Octree& o,
Sequential_tag) Sequential_tag)
{ {
for(const Edge_descriptor& e : o.leaf_edges()) for(const edge_descriptor& e : o.leaf_edges())
f(e); f(e);
} }
@ -111,7 +111,7 @@ public:
const Octree& o, const Octree& o,
CGAL::Sequential_tag) CGAL::Sequential_tag)
{ {
for(const Cell_descriptor& v : o.leaf_voxels()) for(const cell_descriptor& v : o.leaf_voxels())
f(v); 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 FT = typename Geom_traits::FT;
using Point_3 = typename Geom_traits::Point_3; using Point_3 = typename Geom_traits::Point_3;
using Edge_descriptor = typename Domain::Edge_descriptor; using edge_descriptor = typename Domain::edge_descriptor;
using Cell_descriptor = typename Domain::Cell_descriptor; using cell_descriptor = typename Domain::cell_descriptor;
using Point_index = std::size_t; using Point_index = std::size_t;
using Edge_index = std::array<std::size_t, 4>; using Edge_index = std::array<std::size_t, 4>;
@ -140,7 +140,7 @@ public:
m_point_counter(0) m_point_counter(0)
{ } { }
void operator()(const Cell_descriptor& cell) void operator()(const cell_descriptor& cell)
{ {
std::array<FT, 8> values; std::array<FT, 8> values;
std::array<Point_3, 8> corners; std::array<Point_3, 8> corners;
@ -206,7 +206,7 @@ public:
} }
private: 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 // edge is in 0 - 11
@ -293,7 +293,7 @@ private:
m_triangles.push_back({p0, p1, p2}); 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 FT i0,
const std::array<Point_3, 8>& corners, const std::array<Point_3, 8>& corners,
const std::array<FT, 8>& values, 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 Traits<K> Geom_traits;
typedef typename Geom_traits::FT FT; typedef typename Geom_traits::FT FT;
typedef typename Geom_traits::Point_3 Point_3; typedef typename Geom_traits::Point_3 Point_3;
typedef std::size_t Vertex_descriptor; typedef std::size_t vertex_descriptor;
typedef std::size_t Edge_descriptor; typedef std::size_t edge_descriptor;
typedef std::size_t Cell_descriptor; typedef std::size_t cell_descriptor;
typedef std::vector<std::size_t> Vertices_incident_to_edge; 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> Cells_incident_to_edge;
typedef std::vector<std::size_t> Cell_vertices; typedef std::vector<std::size_t> Cell_vertices;
@ -83,15 +83,15 @@ struct MC_Domain
Geom_traits geom_traits() const { return Geom_traits(); } 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 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 {}; } Vertices_incident_to_edge incident_vertices(const edge_descriptor& /*e*/) const { return {}; }
Cells_incident_to_edge incident_cells(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_vertices cell_vertices(const cell_descriptor& /*c*/) const { return {}; }
Cell_edges cell_edges(const Cell_descriptor& /*c*/) const { return {}; } Cell_edges cell_edges(const cell_descriptor& /*c*/) const { return {}; }
template <typename ConcurrencyTag, typename Functor> template <typename ConcurrencyTag, typename Functor>
void for_each_vertex(Functor& /*f*/) const { } void for_each_vertex(Functor& /*f*/) const { }