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

Merge remote-tracking branch 'cgal/master' into Tet_remeshing-with_sizing_field-jtournois

This commit is contained in:
Jane Tournois 2024-04-09 12:45:48 +01:00
parent 2a131effdb dc06506a04
commit 61d4de64b0
93 changed files with 595 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Advancing_front_surface_reconstruction/package_info/Advancing_front_surface_reconstruction/dependencies
View File

@ -23,7 +23,6 @@ Number_types
Polyhedron
Profiling_tools
Property_map
Random_numbers
STL_Extension
Spatial_sorting
Stream_support

27
Algebraic_kernel_d/include/CGAL/Algebraic_kernel_d/Descartes.h
View File

@ -68,9 +68,9 @@ private:
Polynomial poly_;
int number_of_real_roots_;
IT* numerator;
IT* denominator_exponent;
bool* is_exact;
std::vector<IT> numerator;
std::vector<IT> denominator_exponent;
std::vector<bool> is_exact;
IT LEFT,SCALE,DENOM;
bool is_strong_;
int k;
@ -91,9 +91,9 @@ public:
k(kk),
interval_given(false) {
numerator = new IT[CGAL::degree(P)];
denominator_exponent = new IT[CGAL::degree(P)];
is_exact = new bool[CGAL::degree(P)];
numerator.resize(CGAL::degree(P));
denominator_exponent.resize(CGAL::degree(P));
is_exact.resize(CGAL::degree(P));
number_of_real_roots_ = 0;
if(CGAL::degree(P) == 0)
{
@ -116,9 +116,9 @@ public:
k(kk),
interval_given(true) {
numerator = new IT[CGAL::degree(P)];
denominator_exponent = new IT[CGAL::degree(P)];
is_exact = new bool[CGAL::degree(P)];
numerator.resize(CGAL::degree(P));
denominator_exponent.resize(CGAL::degree(P));
is_exact.resize(CGAL::degree(P));
number_of_real_roots_ = 0;
if(CGAL::degree(P) == 0)
{
@ -153,9 +153,9 @@ public:
k(D.k),
interval_given(D.interval_given) {
numerator = new IT[CGAL::degree(poly_)];
denominator_exponent = new IT[CGAL::degree(poly_)];
is_exact = new bool[CGAL::degree(poly_)];
numerator.resize(CGAL::degree(poly_));
denominator_exponent.resize(CGAL::degree(poly_));
is_exact.resize(CGAL::degree(poly_));
for(int i=0; i<number_of_real_roots(); i++)
{
numerator[i] = D.numerator[i];
@ -166,9 +166,6 @@ public:
// destructor
~Descartes() {
delete[] numerator;
delete[] denominator_exponent;
delete[] is_exact;
}
public: // functions

4
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_3.h
View File

@ -1153,15 +1153,17 @@ private:
if(!is_positive(alpha) || !is_positive(offset))
{
#ifdef CGAL_AW3_DEBUG
std::cerr << "Error: invalid input parameters: " << alpha << " and" << offset << std::endl;
std::cerr << "Error: invalid input parameters: " << alpha << " and " << offset << std::endl;
#endif
return false;
}
#ifdef CGAL_AW3_DEBUG
if(refining && alpha > m_alpha)
std::cerr << "Warning: refining with an alpha greater than the last iteration's!" << std::endl;
if(refining && offset != m_offset)
std::cerr << "Warning: refining with a different offset value!" << std::endl;
#endif
m_alpha = FT(alpha);
m_sq_alpha = square(m_alpha);

5
BGL/doc/BGL/BGL.txt
View File

@ -510,11 +510,12 @@ Dynamic property tags, such as `dynamic_vertex_property_t`, are a generalization
value type of the dynamic property map, and a default value.
`boost::property_map<G,T>::%type` is used to obtain the
type of the dynamic property map for a graph of type `G`, for a
dynamic property tag `T`. This type must be default constructible and assignable.
dynamic property tag `T`. This type must be assignable, and if no
default is provided it must be default constructible.
As for ordinary properties, the function `%get()` is overloaded and
serves for retrieving a property map for a given graph and dynamic
property tag, as well as for retrieving a value for a given key and
property map.
property map. The default value is provided as third parameter.
The following example shows how to attach a `string` property to vertices and
a `double` value to the halfedges of a graph.

1
BGL/doc/BGL/Doxyfile.in
View File

@ -34,6 +34,7 @@ ALIASES += "bgllink{1}=<a href=\"http://www.boost.org/libs/graph/doc/\1.html\">
EXTRACT_ALL=NO
HIDE_UNDOC_MEMBERS = YES
HIDE_UNDOC_CLASSES = YES
WARN_IF_INCOMPLETE_DOC = NO
# macros to be used inside the code
ALIASES += "cgalAssociatedTypesBegin=<dl class=\"params\"><dt>Associated Types</dt><dd> <table class=\"params\">"

13
BGL/doc/BGL/PackageDescription.txt
View File

@ -449,6 +449,9 @@ the requirement for traversal of all faces in a graph.
/// \defgroup PkgBGLHelperFct Helper Functions
/// \ingroup PkgBGLRef
/// \defgroup PkgBGLGeneratorFct Generator Functions
/// \ingroup PkgBGLRef
/// \defgroup PkgBGLIterators Iterators and Circulators
/// \ingroup PkgBGLRef
@ -520,7 +523,14 @@ by attaching and initializing external IDs to the elements of the graph.
Generic convenience functions for testing if an edge is a border edge, if a mesh is triangular,
for conversion between models of different `FaceGraph` concepts, etc.
Most functions are in the header file `<CGAL/boost/graph/helpers.h>`
All functions are in the header file `<CGAL/boost/graph/helpers.h>`
*/
/*!
\addtogroup PkgBGLGeneratorrFct
Generic convenience functions for generating meshes such as a triangle, a quad, or a grid.
All functions are in the header file `<CGAL/boost/graph/generators.h>`
*/
/*!
@ -667,6 +677,7 @@ user might encounter.
- `CGAL::is_valid_face_graph()`
- `CGAL::is_valid_polygon_mesh()`
\cgalCRPSection{Generator Functions}
- `CGAL::is_tetrahedron()`
- `CGAL::is_hexahedron()`
- `CGAL::make_triangle()`

2
BGL/examples/BGL_graphcut/face_selection_borders_regularization_example.cpp
View File

@ -2,7 +2,7 @@
#include <CGAL/Surface_mesh.h>
#include <CGAL/boost/graph/selection.h>
#include <CGAL/boost/graph/IO/OFF.h>
#include <CGAL/Random.h>
#include <fstream>
#include <iostream>

1
BGL/examples/BGL_surface_mesh/gwdwg.cpp
View File

@ -4,6 +4,7 @@
#include <CGAL/boost/graph/Graph_with_descriptor_with_graph.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/boost/graph/generators.h>
#include <fstream>

1
BGL/examples/BGL_surface_mesh/write_inp.cpp
View File

@ -1,5 +1,6 @@
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/boost/graph/generators.h>
#include <CGAL/boost/graph/io.h>

125
BGL/include/CGAL/boost/graph/generators.h
View File

@ -19,23 +19,15 @@
#include <CGAL/Random.h>
#include <CGAL/function_objects.h>
#include <CGAL/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/boost/graph/copy_face_graph.h>
#include <array>
#include <iterator>
#include <vector>
namespace CGAL {
namespace Euler {
// Some forward declaration to break the helpers.h > generators.h > Euler_operations.h cycle
template< typename Graph>
void fill_hole(typename boost::graph_traits<Graph>::halfedge_descriptor h,
Graph& g);
template<typename Graph , typename VertexRange >
typename boost::graph_traits<Graph>::face_descriptor add_face(const VertexRange& vr,
Graph& g);
} // namespace Euler
namespace internal {
@ -126,7 +118,7 @@ random_face_in_mesh(const Graph& g, CGAL::Random& rnd = get_default_random())
} // namespace internal
/**
* \ingroup PkgBGLHelperFct
* \ingroup PkgBGLGeneratorFct
*
* \brief creates an isolated triangle
* with its vertices initialized to `p0`, `p1` and `p2`, and adds it to the graph `g`.
@ -256,7 +248,7 @@ struct Default_grid_maker
} // namespace internal
/**
* \ingroup PkgBGLHelperFct
* \ingroup PkgBGLGeneratorFct
*
* \brief creates an isolated quad with
* its vertices initialized to `p0`, `p1`, `p2`, and `p3`, and adds it to the graph `g`.
@ -287,17 +279,35 @@ make_quad(const P& p0, const P& p1, const P& p2, const P& p3, Graph& g)
}
/**
* \ingroup PkgBGLHelperFct
* \ingroup PkgBGLGeneratorFct
* \brief creates an isolated hexahedron
* with its vertices initialized to `p0`, `p1`, ...\ , and `p7`, and adds it to the graph `g`.
* \image html hexahedron.png
* \image latex hexahedron.png
* \returns the halfedge that has the target vertex associated with `p0`, in the face with the vertices with the points `p0`, `p1`, `p2`, and `p3`.
* \returns the halfedge that has the target vertex associated with `p0`,
* in the face with the vertices with the points `p0`, `p1`, `p2`, and `p3`
* (or `p0`, `p2` and `p3` when `do_not_triangulate` is set to `false`).
*
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters"
* among the ones listed below
* \cgalNamedParamsBegin
* \cgalParamNBegin{do_not_triangulate_faces}
* \cgalParamDescription{a Boolean used to specify whether the hexadron's faces
* should be triangulated or not.
* The default value is `true`, and faces are not triangulated.}
* \cgalParamDefault{true}
* \cgalParamNEnd
* \cgalNamedParamsEnd
**/
template<typename Graph, typename P>
template<typename P,
typename Graph,
typename NamedParameters = parameters::Default_named_parameters>
typename boost::graph_traits<Graph>::halfedge_descriptor
make_hexahedron(const P& p0, const P& p1, const P& p2, const P& p3,
const P& p4, const P& p5, const P& p6, const P& p7, Graph& g)
const P& p4, const P& p5, const P& p6, const P& p7,
Graph& g,
const NamedParameters& np = parameters::default_values())
{
typedef typename boost::graph_traits<Graph> Traits;
typedef typename Traits::halfedge_descriptor halfedge_descriptor;
@ -306,6 +316,9 @@ make_hexahedron(const P& p0, const P& p1, const P& p2, const P& p3,
typedef typename boost::property_map<Graph,vertex_point_t>::type Point_property_map;
Point_property_map ppmap = get(CGAL::vertex_point, g);
const bool triangulate = !parameters::choose_parameter(
parameters::get_parameter(np, internal_np::do_not_triangulate_faces), true);
vertex_descriptor v0, v1, v2, v3, v4, v5, v6, v7;
v0 = add_vertex(g);
v1 = add_vertex(g);
@ -326,6 +339,14 @@ make_hexahedron(const P& p0, const P& p1, const P& p2, const P& p3,
halfedge_descriptor ht = internal::make_quad(v4, v5, v6, v7, g);
halfedge_descriptor hb = prev(internal::make_quad(v0, v3, v2, v1, g), g);
std::array<halfedge_descriptor, 6> he_faces;
if(triangulate)
{
he_faces[0] = hb;
he_faces[1] = ht;
}
for(int i=0; i <4; ++i)
{
halfedge_descriptor h = halfedge(add_edge(g), g);
@ -342,14 +363,72 @@ make_hexahedron(const P& p0, const P& p1, const P& p2, const P& p3,
for(int i=0; i <4; ++i)
{
Euler::fill_hole(opposite(hb, g), g);
if(triangulate)
he_faces[i+2] = opposite(hb, g);
hb = next(hb, g);
}
if(triangulate)
{
for (halfedge_descriptor hi : he_faces)
{
halfedge_descriptor nnhi = next(next(hi, g), g);
Euler::split_face(hi, nnhi, g);
}
}
return next(next(hb, g), g);
}
/**
* \ingroup PkgBGLHelperFct
* \ingroup PkgBGLGeneratorFct
* \brief creates an isolated hexahedron
* equivalent to `c`, and adds it to the graph `g`.
* \returns the halfedge that has the target vertex associated with `c.min()`,
* aligned with x-axis,
* in the bottom face of the cuboid.
*
* \tparam IsoCuboid a model of `IsoCuboid_3`
* \tparam Graph a model of `MutableFaceGraph`
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* \param c the iso-cuboid describing the geometry of the hexahedron
* \param g the graph to which the hexahedron will be appended
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters"
* among the ones listed below
* \cgalNamedParamsBegin
* \cgalParamNBegin{do_not_triangulate_faces}
* \cgalParamDescription{a Boolean used to specify whether the hexadron's faces
* should be triangulated or not.
* The default value is `true`, and faces are not triangulated.}
* \cgalParamDefault{true}
* \cgalParamNEnd
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class model of `Kernel`.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
**/
template<typename IsoCuboid,
typename Graph,
typename NamedParameters = parameters::Default_named_parameters>
typename boost::graph_traits<Graph>::halfedge_descriptor
make_hexahedron(const IsoCuboid& c,
Graph& g,
const NamedParameters& np = parameters::default_values())
{
using GT = typename GetGeomTraits<Graph, NamedParameters>::type;
GT gt = parameters::choose_parameter<GT>(
parameters::get_parameter(np, internal_np::geom_traits));
typename GT::Construct_vertex_3 v = gt.construct_vertex_3_object();
return CGAL::make_hexahedron(v(c, 0), v(c, 1), v(c, 2), v(c, 3),
v(c, 4), v(c, 5), v(c, 6), v(c, 7),
g,
np);
}
/**
* \ingroup PkgBGLGeneratorFct
* \brief creates an isolated tetrahedron
* with its vertices initialized to `p0`, `p1`, `p2`, and `p3`, and adds it to the graph `g`.
* \image html tetrahedron.png
@ -447,7 +526,7 @@ make_tetrahedron(const P& p0, const P& p1, const P& p2, const P& p3, Graph& g)
}
/**
* \ingroup PkgBGLHelperFct
* \ingroup PkgBGLGeneratorFct
*
* \brief creates a triangulated regular prism, outward oriented,
* having `nb_vertices` vertices in each of its bases and adds it to the graph `g`.
@ -547,7 +626,7 @@ make_regular_prism(typename boost::graph_traits<Graph>::vertices_size_type nb_ve
}
/**
* \ingroup PkgBGLHelperFct
* \ingroup PkgBGLGeneratorFct
* \brief creates a pyramid, outward oriented, having `nb_vertices` vertices in its base and adds it to the graph `g`.
*
* If `center` is `(0, 0, 0)`, then the first point of the base is `(radius, 0, 0)`
@ -635,7 +714,7 @@ make_pyramid(typename boost::graph_traits<Graph>::vertices_size_type nb_vertices
}
/**
* \ingroup PkgBGLHelperFct
* \ingroup PkgBGLGeneratorFct
*
* \brief creates an icosahedron, outward oriented, centered in `center` and adds it to the graph `g`.
*
@ -730,7 +809,7 @@ make_icosahedron(Graph& g,
}
/*!
* \ingroup PkgBGLHelperFct
* \ingroup PkgBGLGeneratorFct
*
* \brief creates a row major ordered grid with `i` cells along the width and `j` cells
* along the height and adds it to the graph `g`.

3
BGL/include/CGAL/boost/graph/helpers.h
View File

@ -1081,8 +1081,5 @@ int halfedge_index_in_face(typename boost::graph_traits<Graph>::halfedge_descrip
} // namespace CGAL
// Here at the bottom because helpers.h must include generators (for backward compatibility reasons),
// and Euler_operations.h needs helpers.h
#include <CGAL/boost/graph/generators.h>
#endif // CGAL_BOOST_GRAPH_HELPERS_H

2
BGL/test/BGL/next.cpp
View File

@ -2,7 +2,7 @@
#include <iostream>
#include <CGAL/Exact_predicates_exact_constructions_kernel.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/generators.h>
typedef CGAL::Exact_predicates_exact_constructions_kernel K;
typedef K::Point_3 Point_3;

1
BGL/test/BGL/test_Collapse_edge_with_constraints.cpp
View File

@ -1,6 +1,7 @@
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/boost/graph/generators.h>
typedef CGAL::Simple_cartesian<double> K;
typedef K::Point_3 Point_3;

1
BGL/test/BGL/test_Euler_operations.cpp
View File

@ -2,6 +2,7 @@
#include "test_Prefix.h"
#include <boost/range/distance.hpp>
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/boost/graph/generators.h>
#include <CGAL/IO/OFF.h>
#include <CGAL/Polygon_mesh_processing/border.h>

1
BGL/test/BGL/test_Face_filtered_graph.cpp
View File

@ -2,6 +2,7 @@
#include <CGAL/boost/graph/Face_filtered_graph.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/Polygon_mesh_processing/connected_components.h>
#include <CGAL/boost/graph/generators.h>
#include <CGAL/use.h>
#include "test_Prefix.h"

1
BGL/test/BGL/test_test_face.cpp
View File

@ -1,6 +1,7 @@
#include <CGAL/Surface_mesh.h>
#include <CGAL/Simple_cartesian.h>
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/boost/graph/generators.h>
#include <vector>
#include <iostream>

1
Barycentric_coordinates_2/package_info/Barycentric_coordinates_2/dependencies
View File

@ -21,7 +21,6 @@ Number_types
Polygon
Profiling_tools
Property_map
Random_numbers
STL_Extension
Spatial_sorting
Stream_support

1
Combinatorial_map/package_info/Combinatorial_map/dependencies
View File

@ -20,6 +20,5 @@ Modular_arithmetic
Number_types
Profiling_tools
Property_map
Random_numbers
STL_Extension
Stream_support

1
Convex_decomposition_3/package_info/Convex_decomposition_3/dependencies
View File

@ -28,7 +28,6 @@ Polygon
Polyhedron
Profiling_tools
Property_map
Random_numbers
STL_Extension
Spatial_sorting
Stream_support

1
Convex_hull_3/include/CGAL/convex_hull_3.h
View File

@ -33,6 +33,7 @@
#include <CGAL/Number_types/internal/Exact_type_selector.h>
#include <CGAL/boost/graph/copy_face_graph.h>
#include <CGAL/boost/graph/generators.h>
#include <CGAL/Named_function_parameters.h>
#include <CGAL/boost/graph/graph_traits_Triangulation_data_structure_2.h>
#include <CGAL/boost/graph/properties_Triangulation_data_structure_2.h>

4
Documentation/doc/CMakeLists.txt
View File

@ -354,6 +354,10 @@ configure_file(${CGAL_DOC_RESOURCE_DIR}/BaseDoxyfile.in
set(CGAL_DOC_DOXY_DEFAULT "${CGAL_DOC_DXY_DIR}/BaseDoxyfile")
if (BE_QUIET)
file(APPEND ${CGAL_DOC_DOXY_DEFAULT} "WARN_LOGFILE=doxygen.log\n")
endif()
# pkglist_filter gets the path to the pkglist_filter of this source
# directory.
if(WIN32)

1
GraphicsView/include/CGAL/Qt/PolygonWithHolesGraphicsItem.h
View File

@ -19,7 +19,6 @@
#include <CGAL/Bbox_2.h>
#include <CGAL/Polygon_with_holes_2.h>
#include <CGAL/apply_to_range.h>
#include <CGAL/Qt/PainterOstream.h>
#include <CGAL/Qt/GraphicsItem.h>
#include <CGAL/Qt/Converter.h>

0
Triangulation_2/include/CGAL/apply_to_range.h → GraphicsView/include/CGAL/apply_to_range.h
View File

1
GraphicsView/package_info/GraphicsView/dependencies
View File

@ -11,4 +11,3 @@ Number_types
Profiling_tools
STL_Extension
Stream_support
Triangulation_2

22
HalfedgeDS/include/CGAL/boost/graph/properties_HalfedgeDS_base.h
View File

@ -21,6 +21,7 @@
#include <memory>
#include <CGAL/boost/graph/internal/Has_member_id.h>
#include <CGAL/Distance_3/Point_3_Point_3.h>
#include <CGAL/Dynamic_property_map.h>
namespace CGAL {
@ -126,11 +127,20 @@ typename boost::property_map<CGAL_HDS_CLASS, PropertyTag >::type
get(PropertyTag,CGAL_HDS_CLASS&)
{ return typename boost::property_map<CGAL_HDS_CLASS, PropertyTag >::type(); }
// generalized 3-ary get functions
template<class CGAL_HDS_TMPLT, class PropertyTag, class Key>
template<class CGAL_HDS_TMPLT, class PropertyTag, class Key,
class F = std::enable_if_t<!std::is_same_v<PropertyTag, dynamic_vertex_property_t<Key>> &&
!std::is_same_v<PropertyTag, dynamic_halfedge_property_t<Key>> &&
!std::is_same_v<PropertyTag, dynamic_edge_property_t<Key>> &&
!std::is_same_v<PropertyTag, dynamic_face_property_t<Key>>
>
>
typename boost::property_traits< typename boost::property_map<CGAL_HDS_CLASS, PropertyTag >::type >::reference
get(PropertyTag p,CGAL_HDS_CLASS& g, const Key& key)
{ return get(get(p, g), key); }
{
return get(get(p, g), key);
}
template<class CGAL_HDS_TMPLT, class PropertyTag, class Key>
typename boost::property_traits< typename boost::property_map<CGAL_HDS_CLASS, PropertyTag >::const_type >::reference
@ -139,13 +149,13 @@ get(PropertyTag p,CGAL_HDS_CLASS const& g, const Key& key)
#define DECLARE_HDS_DYNAMIC_PM(TAG, DESCRIPTOR) \
#define DECLARE_HDS_DYNAMIC_PM(TAG, DESCRIPTOR) \
template <typename CGAL_HDS_TMPLT, class T> \
typename boost::property_map<CGAL_HDS_CLASS, TAG >::const_type \
get(const TAG&, const CGAL_HDS_CLASS&) \
{ \
get(const TAG&, const CGAL_HDS_CLASS&, const T& dv = T()) \
{ \
typedef typename boost::graph_traits< CGAL_HDS_CLASS >::DESCRIPTOR descriptor; \
return internal::Dynamic_property_map<descriptor,T>(); \
return internal::Dynamic_property_map<descriptor,T>(dv); \
}
DECLARE_HDS_DYNAMIC_PM(dynamic_vertex_property_t<T>, vertex_descriptor)

2
Hash_map/test/Hash_map/Hash.cpp
View File

@ -11,9 +11,9 @@
#include <CGAL/Linear_cell_complex_for_generalized_map.h>
#include <CGAL/boost/graph/graph_traits_Arrangement_2.h>
#include <CGAL/boost/graph/graph_traits_Triangulation_2.h>
#include <CGAL/boost/graph/generators.h>
#include <map>
#include <boost/unordered_map.hpp>
#include <CGAL/boost/graph/helpers.h>
typedef CGAL::Simple_cartesian<double> Kernel;

1
Heat_method_3/package_info/Heat_method_3/dependencies
View File

@ -12,7 +12,6 @@ Modular_arithmetic
Number_types
Profiling_tools
Property_map
Random_numbers
STL_Extension
Solver_interface
Stream_support

2
Installation/CHANGES.md
View File

@ -70,6 +70,8 @@ Release date: October 2023
`CGAL::Polygon_mesh_processing::autorefine_triangle_soup()` that refines a soup of triangles so that no pair of triangles intersects
in their interiors. Also added, the function `autorefine()` operating directly on a triangle mesh and updating it
using the aforementioned function on a triangle soup.
- Added the function `CGAL::Polygon_mesh_processing::add_bbox()` that enables to add a tight or extended, triangulated or not,
bounding box to a face graph.
### [2D Arrangements](https://doc.cgal.org/6.0/Manual/packages.html#PkgArrangementOnSurface2)
- Fixed a bug in the zone construction code applied to arrangements of geodesic arcs on a sphere,

2
Installation/CMakeLists.txt
View File

@ -1052,7 +1052,7 @@ You must disable CGAL_ENABLE_CHECK_HEADERS.")
execute_process(
COMMAND
"${CMAKE_COMMAND}" -DCGAL_BUILD_THREE_DOC=TRUE
-DDOXYGEN_EXECUTABLE=${DOXYGEN_EXECUTABLE}
-DDOXYGEN_EXECUTABLE=${DOXYGEN_EXECUTABLE} -DBE_QUIET=TRUE
"${CGAL_SOURCE_DIR}/Documentation/doc"
WORKING_DIRECTORY "${DOC_DIR}")
execute_process(

6
Kernel_23/doc/Kernel_23/CGAL/Bbox_2.h
View File

@ -102,6 +102,12 @@ dilates the bounding box by a specified number of ULP.
*/
void dilate(int dist);
/*!
scales the bounding box by `factor`, while keeping its center fixed.
\pre `factor > 0`
*/
void scale(double factor);
/// @}
}; /* end Bbox_2 */

7
Kernel_23/doc/Kernel_23/CGAL/Bbox_3.h
View File

@ -115,6 +115,13 @@ Bbox_3& operator+=(const Bbox_3 &c);
dilates the bounding box by a specified number of ULP.
*/
void dilate(int dist);
/*!
scales the bounding box by `factor`, while keeping its center fixed.
\pre `factor > 0`
*/
void scale(double factor);
/// @}
}; /* end Bbox_3 */

20
Kernel_23/include/CGAL/Bbox_2.h
View File

@ -71,6 +71,7 @@ public:
inline Bbox_2& operator+=(const Bbox_2 &b);
inline void dilate(int dist);
inline void scale(double factor);
};
inline
@ -170,6 +171,25 @@ Bbox_2::dilate(int dist)
rep[3] = float_advance(rep[3],dist);
}
inline
void
Bbox_2::scale(double factor)
{
CGAL_precondition(factor > 0);
if(factor == 1.)
return;
std::array<double, 2> half_width = { (xmax() - xmin()) * 0.5,
(ymax() - ymin()) * 0.5 };
std::array<double, 2> center = { xmin() + half_width[0],
ymin() + half_width[1] };
rep[0] = center[0] - factor * half_width[0];
rep[1] = center[1] - factor * half_width[1];
rep[2] = center[0] + factor * half_width[0];
rep[3] = center[1] + factor * half_width[1];
}
inline
bool
do_overlap(const Bbox_2 &bb1, const Bbox_2 &bb2)

25
Kernel_23/include/CGAL/Bbox_3.h
View File

@ -76,7 +76,8 @@ public:
Bbox_3 operator+(const Bbox_3& b) const;
Bbox_3& operator+=(const Bbox_3& b);
void dilate(int dist);
inline void dilate(int dist);
inline void scale(double factor);
};
inline
@ -200,6 +201,28 @@ Bbox_3::dilate(int dist)
rep[5] = float_advance(rep[5],dist);
}
inline
void
Bbox_3::scale(double factor)
{
CGAL_precondition(factor > 0);
if (factor == 1.)
return;
std::array<double, 3> half_width = { (xmax() - xmin()) * 0.5,
(ymax() - ymin()) * 0.5,
(zmax() - zmin()) * 0.5 };
std::array<double, 3> center = { xmin() + half_width[0],
ymin() + half_width[1],
zmin() + half_width[2] };
rep[0] = center[0] - factor * half_width[0];
rep[1] = center[1] - factor * half_width[1];
rep[2] = center[2] - factor * half_width[2];
rep[3] = center[0] + factor * half_width[0];
rep[4] = center[1] + factor * half_width[1];
rep[5] = center[2] + factor * half_width[2];
}
inline
bool

1
Linear_cell_complex/package_info/Linear_cell_complex/dependencies
View File

@ -24,6 +24,5 @@ Modular_arithmetic
Number_types
Profiling_tools
Property_map
Random_numbers
STL_Extension
Stream_support

1
Linear_cell_complex/test/Linear_cell_complex/Linear_cell_complex_2_test.h
View File

@ -17,6 +17,7 @@
#include <CGAL/Linear_cell_complex_constructors.h>
#include <CGAL/Triangulation_2_to_lcc.h>
#include <CGAL/Delaunay_triangulation_2.h>
#include <CGAL/Random.h>
#include <fstream>
// #define LCC_TRACE_TEST_BEGIN 1

1
Mesh_2/include/CGAL/Mesh_2/Mesh_global_optimizer_2.h
View File

@ -29,6 +29,7 @@
#include <CGAL/Constrained_voronoi_diagram_2.h>
#include <vector>
#include <set>
#include <list>
#include <algorithm>
#include <iterator>

1
Minkowski_sum_3/package_info/Minkowski_sum_3/dependencies
View File

@ -29,7 +29,6 @@ Polygon
Polyhedron
Profiling_tools
Property_map
Random_numbers
STL_Extension
Spatial_sorting
Stream_support

1
Nef_3/include/CGAL/Nef_3/polygon_mesh_to_nef_3.h
View File

@ -27,6 +27,7 @@
#include <CGAL/Point_3.h>
#include <CGAL/Vector_3.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/named_params_helper.h>
#undef CGAL_NEF_DEBUG
#define CGAL_NEF_DEBUG 29

1
Nef_3/package_info/Nef_3/dependencies
View File

@ -29,7 +29,6 @@ Polygon_mesh_processing
Polyhedron
Profiling_tools
Property_map
Random_numbers
STL_Extension
Spatial_sorting
Stream_support

19
Number_types/include/CGAL/Number_types/internal/Exact_type_selector.h
View File

@ -317,6 +317,25 @@ template < typename ET >
struct Exact_type_selector : Exact_field_selector< ET > {};
#endif
constexpr const char* exact_nt_backend_string()
{
switch(Default_exact_nt_backend)
{
case GMP_BACKEND:
return "GMP_BACKEND";
case GMPXX_BACKEND:
return "GMPXX_BACKEND";
case BOOST_GMP_BACKEND:
return "BOOST_GMP_BACKEND";
case BOOST_BACKEND:
return "BOOST_BACKEND";
case LEDA_BACKEND:
return "LEDA_BACKEND";
default:
return "MP_FLOAT_BACKEND";
}
}
} } // namespace CGAL::internal
#undef CGAL_EXACT_SELECTORS_SPECS

1
Number_types/test/Number_types/CMakeLists.txt
View File

@ -61,6 +61,7 @@ create_single_source_cgal_program("unsigned.cpp")
create_single_source_cgal_program("utilities.cpp")
create_single_source_cgal_program("Exact_rational.cpp")
create_single_source_cgal_program("Mpzf_new.cpp")
create_single_source_cgal_program("check_exact_backend.cpp")
if( CGAL_Core_FOUND )
create_single_source_cgal_program( "CORE_Expr_ticket_4296.cpp" )

40
Number_types/test/Number_types/check_exact_backend.cpp Normal file
View File

@ -0,0 +1,40 @@
#include <CGAL/config.h>
#include <CGAL/Exact_integer.h>
#include <CGAL/Exact_rational.h>
#include <type_traits>
using namespace CGAL::internal;
int main()
{
static_assert(
#ifdef CGAL_USE_GMP
( Default_exact_nt_backend!=GMP_BACKEND || (std::is_same_v<CGAL::Exact_integer,CGAL::Gmpz> && std::is_same_v<CGAL::Exact_rational,CGAL::Gmpq>) ) &&
#endif
#ifdef CGAL_USE_GMPXX
( Default_exact_nt_backend!=GMPXX_BACKEND || (std::is_same_v<CGAL::Exact_integer,mpz_class> && std::is_same_v<CGAL::Exact_rational,mpq_class>) ) &&
#endif
#if defined(CGAL_USE_BOOST_MP) && defined(CGAL_USE_GMP)
( Default_exact_nt_backend!=BOOST_GMP_BACKEND || (std::is_same_v<CGAL::Exact_integer,boost::multiprecision::mpz_int> && std::is_same_v<CGAL::Exact_rational,boost::multiprecision::mpq_rational>) ) &&
#endif
#if defined(CGAL_USE_BOOST_MP)
( Default_exact_nt_backend!=BOOST_BACKEND || (std::is_same_v<CGAL::Exact_integer,boost::multiprecision::cpp_int> && std::is_same_v<CGAL::Exact_rational,boost::multiprecision::cpp_rational>) ) &&
#endif
#if defined(CGAL_USE_LEDA)
( Default_exact_nt_backend!=LEDA_BACKEND || (std::is_same_v<CGAL::Exact_integer,leda_integer> && std::is_same_v<CGAL::Exact_rational,leda_rational>) ) &&
#endif
( Default_exact_nt_backend!=MP_FLOAT_BACKEND || (std::is_same_v<CGAL::Exact_integer,CGAL::MP_Float> && std::is_same_v<CGAL::Exact_rational,CGAL::Quotient<CGAL::MP_Float>>) )
);
std::cout << "Exact backend is " << exact_nt_backend_string() << "\n";
#ifdef CGAL_USE_CORE
#ifdef CGAL_CORE_USE_GMP_BACKEND
std::cout << "CGAL_CORE_USE_GMP_BACKEND is defined, using gmp backend in BigInt and BigRat\n";
#else
std::cout << "CGAL_CORE_USE_GMP_BACKEND is NOT defined, using boost-mp backend in BigInt and BigRat\n";
#endif
#else
std::cout << "CGAL_USE_CORE is not defined\n";
#endif
}

1
Optimal_bounding_box/include/CGAL/Optimal_bounding_box/oriented_bounding_box.h
View File

@ -24,6 +24,7 @@
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/boost/graph/generators.h>
#include <CGAL/convex_hull_3.h>
#include <CGAL/Convex_hull_traits_3.h>
#include <CGAL/Default.h>

1
Periodic_4_hyperbolic_triangulation_2/demo/Periodic_4_hyperbolic_triangulation_2/include/internal/Qt/TriangulationGraphicsItem.h
View File

@ -14,7 +14,6 @@
#define CGAL_QT_TRIANGULATION_GRAPHICS_ITEM_H
#include <CGAL/Bbox_2.h>
#include <CGAL/apply_to_range.h>
#include <CGAL/Qt/PainterOstream.h>
#include <CGAL/Qt/GraphicsItem.h>

1
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/Non_manifold_feature_map.h
View File

@ -75,6 +75,7 @@ struct Non_manifold_feature_map
halfedge_descriptor hd = halfedge(ed, pm);
// an edge can be non-manifold only if both its vertices are non-manifold
// THIS IS NOT TRUE!
if ( get(v_nm_id, source(hd, pm))==std::size_t(-1) ||
get(v_nm_id, target(hd, pm))==std::size_t(-1) ) continue;

10
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/angle_and_area_smoothing.h
View File

@ -134,7 +134,6 @@ void angle_and_area_smoothing(const FaceRange& faces,
TriangleMesh& tmesh,
const NamedParameters& np = parameters::default_values())
{
typedef typename boost::graph_traits<TriangleMesh>::vertex_descriptor vertex_descriptor;
typedef typename boost::graph_traits<TriangleMesh>::halfedge_descriptor halfedge_descriptor;
typedef typename boost::graph_traits<TriangleMesh>::edge_descriptor edge_descriptor;
typedef typename boost::graph_traits<TriangleMesh>::face_descriptor face_descriptor;
@ -209,14 +208,7 @@ void angle_and_area_smoothing(const FaceRange& faces,
const bool use_Delaunay_flips = choose_parameter(get_parameter(np, internal_np::use_Delaunay_flips), true);
VCMap vcmap = choose_parameter(get_parameter(np, internal_np::vertex_is_constrained),
get(Vertex_property_tag(), tmesh));
// If it's the default vcmap, manually set everything to false because the dynamic pmap has no default initialization
if((std::is_same<VCMap, Default_VCMap>::value))
{
for(vertex_descriptor v : vertices(tmesh))
put(vcmap, v, false);
}
get(Vertex_property_tag(), tmesh, false));
ECMap ecmap = choose_parameter(get_parameter(np, internal_np::edge_is_constrained),
Static_boolean_property_map<edge_descriptor, false>());

79
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/bbox.h
View File

@ -15,14 +15,16 @@
#include <CGAL/license/Polygon_mesh_processing/miscellaneous.h>
#include <CGAL/Bbox_3.h>
#include <boost/graph/graph_traits.hpp>
#include <CGAL/boost/graph/generators.h>
#include <boost/graph/graph_traits.hpp>
#include <CGAL/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <vector>
namespace CGAL {
namespace Polygon_mesh_processing {
@ -54,6 +56,14 @@ namespace CGAL {
* `Construct_bbox_3` must provide the functor `Bbox_3 operator()(Point_3)`
* where `%Point_3` is the value type of the vertex point map.}
* \cgalParamNEnd
*
* \cgalParamNBegin{bbox_scaling}
* \cgalParamDescription{a double used to scale the bounding box.
* The default value is 1 and the bounding box is the smallest possible
* axis-aligned bounding box.}
* \cgalParamDefault{1.}
* \cgalParamPrecondition{`bbox_scaling > 0`}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @see `vertex_bbox()`
@ -75,6 +85,9 @@ namespace CGAL {
GT gt = choose_parameter<GT>(get_parameter(np, internal_np::geom_traits));
typename GT::Construct_bbox_3 get_bbox = gt.construct_bbox_3_object();
const double factor = choose_parameter(get_parameter(np, internal_np::bbox_scaling), 1.);
CGAL_precondition(factor > 0);
typedef typename boost::graph_traits<PolygonMesh>::vertex_descriptor vertex_descriptor;
CGAL::Bbox_3 bb;
@ -82,6 +95,8 @@ namespace CGAL {
{
bb += get_bbox( get(vpm, v) );
}
bb.scale(factor);
return bb;
}
@ -255,6 +270,66 @@ namespace CGAL {
}
return bb;
}
/*!
* \ingroup PkgPolygonMeshProcessingRef
*
* adds an axis-aligned bounding box to a polygon mesh.
*
* @tparam PolygonMesh a model of `MutableFaceGraph`
* @tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* @param pmesh a polygon mesh
* @param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamNBegin{bbox_scaling}
* \cgalParamDescription{a double used to scale the bounding box.
* The default value is 1 and the bounding box is the smallest possible
* axis-aligned bounding box.}
* \cgalParamDefault{1.}
* \cgalParamPrecondition{`bbox_scaling > 0`}
* \cgalParamNEnd
* \cgalParamNBegin{do_not_triangulate_faces}
* \cgalParamDescription{a Boolean used to specify whether the bounding box's faces
* should be triangulated or not.
* The default value is `true`, and faces are not triangulated.}
* \cgalParamDefault{true}
* \cgalParamNEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
* \cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<PolygonMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, pmesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `PolygonMesh`.}
* \cgalParamNEnd
* \cgalParamNBegin{geom_traits}
* \cgalParamDescription{an instance of a geometric traits class model of `Kernel`.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*
* @see `bbox()`
*/
template<typename PolygonMesh,
typename NamedParameters = parameters::Default_named_parameters>
void add_bbox(PolygonMesh& pmesh,
const NamedParameters& np = parameters::default_values())
{
using parameters::choose_parameter;
using parameters::get_parameter;
using GT = typename GetGeomTraits<PolygonMesh, NamedParameters>::type;
using P = typename GT::Point_3;
GT gt = choose_parameter<GT>(get_parameter(np, internal_np::geom_traits));
typename GT::Construct_iso_cuboid_3
iso_cuboid = gt.construct_iso_cuboid_3_object();
const CGAL::Bbox_3 bb = bbox(pmesh, np);
CGAL::make_hexahedron(iso_cuboid(P(bb.xmin(), bb.ymin(), bb.zmin()),
P(bb.xmax(), bb.ymax(), bb.zmax())),
pmesh, np);
}
}
}

10
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/clip.h
View File

@ -566,7 +566,7 @@ generic_clip_impl(
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm` and `clipper` will be
* \cgalParamDescription{If `true`, the set of triangles close to the intersection of `tm` and `clipper` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}
@ -668,7 +668,7 @@ clip(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm`
* \cgalParamDescription{If `true`, the set of triangles close to the intersection of `tm`
* and `plane` will be checked for self-intersections
* and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}
@ -778,7 +778,7 @@ bool clip(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm`
* \cgalParamDescription{If `true`, the set of triangles close to the intersection of `tm`
* and `iso_cuboid` will be checked for self-intersections
* and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}
@ -980,7 +980,7 @@ void split(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm`
* \cgalParamDescription{If `true`, the set of triangles close to the intersection of `tm`
* and `plane` will be checked for self-intersections
* and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}
@ -1069,7 +1069,7 @@ void split(TriangleMesh& tm,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm`
* \cgalParamDescription{If `true`, the set of triangles close to the intersection of `tm`
* and `iso_cuboid` will be checked for self-intersections
* and `CGAL::Polygon_mesh_processing::Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}

6
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h
View File

@ -138,7 +138,7 @@ enum Boolean_operation_type {UNION = 0, INTERSECTION=1,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm1` and `tm2` will be
* \cgalParamDescription{If `true`, the set of triangles close to the intersection of `tm1` and `tm2` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}
@ -477,7 +477,7 @@ corefine_and_compute_boolean_operations(
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true` the set of triangles closed to the intersection of `tm1` and `tm2` will be
* \cgalParamDescription{If `true` the set of triangles close to the intersection of `tm1` and `tm2` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}
@ -644,7 +644,7 @@ corefine_and_compute_difference( TriangleMesh& tm1,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true` the set of triangles closed to the intersection of `tm1` and `tm2` will be
* \cgalParamDescription{If `true` the set of triangles close to the intersection of `tm1` and `tm2` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}

5
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Smoothing/mesh_smoothing_impl.h
View File

@ -154,11 +154,8 @@ public:
typedef typename boost::property_map<TriangleMesh,
Edge_property_tag>::type Marked_edges_map;
Marked_edges_map marks = get(Edge_property_tag(), mesh_);
Marked_edges_map marks = get(Edge_property_tag(), mesh_, false);
// dynamic pmaps do not have default values...
for(edge_descriptor e : edges(mesh_))
put(marks, e, false);
for(edge_descriptor e : edge_range)
put(marks, e, true);
#ifdef CGAL_PMP_SMOOTHING_DEBUG

13
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/Snapping/snap.h
View File

@ -27,6 +27,7 @@
#include <CGAL/Named_function_parameters.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/Polygon_mesh_processing/border.h>
#include <CGAL/Polygon_mesh_processing/compute_normal.h>
@ -104,9 +105,7 @@ void simplify_range(HalfedgeRange& halfedge_range,
typedef CGAL::dynamic_halfedge_property_t<bool> Halfedge_bool_tag;
typedef typename boost::property_map<TriangleMesh, Halfedge_bool_tag>::type Range_halfedges;
Range_halfedges range_halfedges = get(Halfedge_bool_tag(), tm);
for(halfedge_descriptor h : halfedge_range)
put(range_halfedges, h, true);
Range_halfedges range_halfedges = get(Halfedge_bool_tag(), tm, false);
CGAL_postcondition_code(const std::size_t initial_n = halfedge_range.size();)
@ -1233,10 +1232,10 @@ std::size_t snap_non_conformal(HalfedgeRange& halfedge_range_A,
// We keep in memory pairs of source/target edges that are stitchable after vertex-vertex snapping
// --> these halfedges should not be considered as targets in non-conformal snapping
// Similarly, matching vertices whose incident edges have matching directions are also locked
Locked_vertices locked_vertices_A = get(Vertex_bool_tag(), tm_A);
Locked_vertices locked_vertices_B = get(Vertex_bool_tag(), tm_B);
Locked_halfedges locked_halfedges_A = get(Halfedge_bool_tag(), tm_A);
Locked_halfedges locked_halfedges_B = get(Halfedge_bool_tag(), tm_B);
Locked_vertices locked_vertices_A = get(Vertex_bool_tag(), tm_A, false);
Locked_vertices locked_vertices_B = get(Vertex_bool_tag(), tm_B, false);
Locked_halfedges locked_halfedges_A = get(Halfedge_bool_tag(), tm_A, false);
Locked_halfedges locked_halfedges_B = get(Halfedge_bool_tag(), tm_B, false);
std::vector<std::pair<vertex_descriptor, vertex_descriptor> > locked_vertices;
std::vector<halfedge_descriptor> locked_halfedges_A_vector, locked_halfedges_B_vector;

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/intersection.h
View File

@ -1711,7 +1711,7 @@ OutputIterator intersecting_meshes(const TriangleMeshRange& range,
* \cgalParamNEnd
*
* \cgalParamNBegin{throw_on_self_intersection}
* \cgalParamDescription{If `true`, the set of triangles closed to the intersection of `tm1` and `tm2` will be
* \cgalParamDescription{If `true`, the set of triangles close to the intersection of `tm1` and `tm2` will be
* checked for self-intersections and `Corefinement::Self_intersection_exception`
* will be thrown if at least one self-intersection is found.}
* \cgalParamType{Boolean}

19
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/manifoldness.h
View File

@ -58,9 +58,7 @@ bool is_non_manifold_vertex(typename boost::graph_traits<PolygonMesh>::vertex_de
typedef typename boost::property_map<PolygonMesh, Halfedge_property_tag>::const_type Visited_halfedge_map;
// Dynamic pmaps do not have default initialization values (yet)
Visited_halfedge_map visited_halfedges = get(Halfedge_property_tag(), pm);
for(halfedge_descriptor h : halfedges(pm))
put(visited_halfedges, h, false);
Visited_halfedge_map visited_halfedges = get(Halfedge_property_tag(), pm, false);
std::size_t incident_null_faces_counter = 0;
for(halfedge_descriptor h : halfedges_around_target(v, pm))
@ -324,20 +322,11 @@ OutputIterator non_manifold_vertices(const PolygonMesh& pm,
typedef CGAL::dynamic_halfedge_property_t<bool> Halfedge_property_tag;
typedef typename boost::property_map<PolygonMesh, Halfedge_property_tag>::const_type Visited_halfedge_map;
Known_manifold_vertex_map known_nm_vertices = get(Vertex_bool_tag(), pm);
Visited_vertex_map visited_vertices = get(Vertex_halfedge_tag(), pm);
Visited_halfedge_map visited_halfedges = get(Halfedge_property_tag(), pm);
halfedge_descriptor null_h = boost::graph_traits<PolygonMesh>::null_halfedge();
// Dynamic pmaps do not have default initialization values (yet)
for(vertex_descriptor v : vertices(pm))
{
put(known_nm_vertices, v, false);
put(visited_vertices, v, null_h);
}
for(halfedge_descriptor h : halfedges(pm))
put(visited_halfedges, h, false);
Known_manifold_vertex_map known_nm_vertices = get(Vertex_bool_tag(), pm, false);
Visited_vertex_map visited_vertices = get(Vertex_halfedge_tag(), pm, null_h);
Visited_halfedge_map visited_halfedges = get(Halfedge_property_tag(), pm, false);
for(halfedge_descriptor h : halfedges(pm))
{

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/repair_degeneracies.h
View File

@ -639,7 +639,7 @@ bool remove_almost_degenerate_faces(const FaceRange& face_range,
// Vertex property map that combines the VCM and the fact that extremities of a constrained edge should be constrained
typedef CGAL::dynamic_vertex_property_t<bool> Vertex_property_tag;
typedef typename boost::property_map<TriangleMesh, Vertex_property_tag>::type DVCM;
DVCM vcm = get(Vertex_property_tag(), tmesh);
DVCM vcm = get(Vertex_property_tag(), tmesh, false);
// parameters
const double cap_threshold =

2
Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/stitch_borders.h
View File

@ -190,7 +190,7 @@ struct Boundary_cycle_rep_maintainer
Boundary_cycle_rep_maintainer(PolygonMesh& pmesh)
: m_pmesh(pmesh)
{
m_candidate_halfedges = get(Candidate_tag(), pmesh);
m_candidate_halfedges = get(Candidate_tag(), pmesh, false);
}
public:

2
Polygon_mesh_processing/test/Polygon_mesh_processing/connected_component_surface_mesh.cpp
View File

@ -1,7 +1,7 @@
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/generators.h>
#include <CGAL/Polygon_mesh_processing/connected_components.h>
#include <CGAL/property_map.h>

2
Polygon_mesh_processing/test/Polygon_mesh_processing/test_pmp_transform.cpp
View File

@ -1,7 +1,7 @@
#include <CGAL/Polygon_mesh_processing/transform.h>
#include <CGAL/boost/graph/generators.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/Aff_transformation_3.h>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>

1
Polygon_mesh_processing/test/Polygon_mesh_processing/test_stitching.cpp
View File

@ -5,6 +5,7 @@
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/boost/graph/copy_face_graph.h>
#include <CGAL/boost/graph/generators.h>
#include <CGAL/Dynamic_property_map.h>
#include <CGAL/Polyhedron_3.h>

1
Polygonal_surface_reconstruction/package_info/Polygonal_surface_reconstruction/dependencies
View File

@ -28,7 +28,6 @@ Principal_component_analysis
Principal_component_analysis_LGPL
Profiling_tools
Property_map
Random_numbers
STL_Extension
Solver_interface
Spatial_searching

1
Polyhedron/demo/Polyhedron/Plugins/PCA/Basic_generator_plugin.cpp
View File

@ -8,6 +8,7 @@
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/boost/graph/generators.h>
#include <CGAL/subdivision_method_3.h>
#include <CGAL/Kernel_traits.h>

1
Polyhedron/demo/Polyhedron/Plugins/PCA/Clipping_box_plugin.cpp
View File

@ -15,6 +15,7 @@
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/Polygon_mesh_processing/compute_normal.h>
#include <CGAL/boost/graph/generators.h>
#include "Selection_visualizer.h"
#include "Scene_plane_item.h"

4
Polyhedron/demo/Polyhedron/Plugins/PCA/Create_bbox_mesh_plugin.cpp
View File

@ -3,6 +3,8 @@
#include <CGAL/Three/Scene_item.h>
#include <CGAL/Three/Scene_interface.h>
#include <CGAL/boost/graph/generators.h>
#include <QAction>
#include <QMainWindow>
#include <QMessageBox>
@ -164,7 +166,7 @@ bbox(bool extended)
Scene_item* item;
EPICK::Iso_cuboid_3 ic(bbox);
SMesh* p = new SMesh;
CGAL::make_hexahedron(ic[0], ic[1], ic[2], ic[3], ic[4], ic[5], ic[6], ic[7], *p);
CGAL::make_hexahedron(ic, *p);
item = new Scene_surface_mesh_item(p);
item->setName(name + (extended ? " (Extended Bbox)" : " (Bbox)"));

1
Polyhedron/demo/Polyhedron/Plugins/PCA/Edit_box_plugin.cpp
View File

@ -7,6 +7,7 @@
#include <CGAL/Three/Viewer_interface.h>
#include <CGAL/Three/Three.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/generators.h>
#include <QAction>
#include <QMainWindow>
#include <QApplication>

1
Polyhedron/demo/Polyhedron/Plugins/PCA/Pca_plugin.cpp
View File

@ -11,6 +11,7 @@
#include <CGAL/bounding_box.h>
#include <CGAL/linear_least_squares_fitting_3.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/generators.h>
#include "Kernel_type.h"
#include <CGAL/Three/Three.h>

105
Polyhedron/demo/Polyhedron/Plugins/PMP/AddBboxDialog.ui Normal file
View File

@ -0,0 +1,105 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>AddBboxDialog</class>
<widget class="QDialog" name="AddBboxDialog">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>413</width>
<height>108</height>
</rect>
</property>
<property name="windowTitle">
<string>Dialog</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QCheckBox" name="triangulate_bbox">
<property name="text">
<string>Triangulate bbox</string>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Scaling :</string>
</property>
</widget>
</item>
<item>
<widget class="DoubleEdit" name="bbox_scaling"/>
</item>
</layout>
</item>
<item>
<widget class="QDialogButtonBox" name="buttonBox">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="standardButtons">
<set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<customwidgets>
<customwidget>
<class>DoubleEdit</class>
<extends>QLineEdit</extends>
<header location="global">CGAL_double_edit.h</header>
</customwidget>
</customwidgets>
<connections>
<connection>
<sender>buttonBox</sender>
<signal>accepted()</signal>
<receiver>AddBboxDialog</receiver>
<slot>accept()</slot>
<hints>
<hint type="sourcelabel">
<x>248</x>
<y>254</y>
</hint>
<hint type="destinationlabel">
<x>157</x>
<y>274</y>
</hint>
</hints>
</connection>
<connection>
<sender>buttonBox</sender>
<signal>rejected()</signal>
<receiver>AddBboxDialog</receiver>
<slot>reject()</slot>
<hints>
<hint type="sourcelabel">
<x>316</x>
<y>260</y>
</hint>
<hint type="destinationlabel">
<x>286</x>
<y>274</y>
</hint>
</hints>
</connection>
</connections>
</ui>

3
Polyhedron/demo/Polyhedron/Plugins/PMP/CMakeLists.txt
View File

@ -131,14 +131,13 @@ target_link_libraries(
PUBLIC scene_surface_mesh_item scene_polylines_item
scene_points_with_normal_item)
qt6_wrap_ui( repairUI_FILES RemoveNeedlesDialog.ui SelfSnapDialog.ui)
qt6_wrap_ui( repairUI_FILES RemoveNeedlesDialog.ui SelfSnapDialog.ui AddBboxDialog.ui)
polyhedron_demo_plugin(repair_polyhedron_plugin Repair_polyhedron_plugin ${repairUI_FILES} KEYWORDS PMP)
target_link_libraries(repair_polyhedron_plugin PUBLIC scene_points_with_normal_item scene_surface_mesh_item scene_polygon_soup_item)
if(TARGET CGAL::TBB_support)
target_link_libraries(repair_polyhedron_plugin PUBLIC CGAL::TBB_support)
endif()
if(TARGET CGAL::Eigen3_support)
qt6_wrap_ui(isotropicRemeshingUI_FILES Isotropic_remeshing_dialog.ui)
polyhedron_demo_plugin(isotropic_remeshing_plugin Isotropic_remeshing_plugin

46
Polyhedron/demo/Polyhedron/Plugins/PMP/Repair_polyhedron_plugin.cpp
View File

@ -25,6 +25,7 @@
#include "ui_RemoveNeedlesDialog.h"
#include "ui_SelfSnapDialog.h"
#include "ui_AddBboxDialog.h"
#include <cmath>
#include <limits>
#include <vector>
@ -60,6 +61,7 @@ public:
actionAutorefineAndRMSelfIntersections = new QAction(tr("Autorefine and Remove Self-Intersections (Deprecated)"), mw);
actionRemoveNeedlesAndCaps = new QAction(tr("Remove Needles And Caps"));
actionSnapBorders = new QAction(tr("Snap Boundaries"));
actionAddBbox = new QAction(tr("Add Bounding Box"));
actionRemoveIsolatedVertices->setObjectName("actionRemoveIsolatedVertices");
actionRemoveDegenerateFaces->setObjectName("actionRemoveDegenerateFaces");
@ -73,6 +75,7 @@ public:
actionAutorefineAndRMSelfIntersections->setObjectName("actionAutorefineAndRMSelfIntersections");
actionRemoveNeedlesAndCaps->setObjectName("actionRemoveNeedlesAndCaps");
actionSnapBorders->setObjectName("actionSnapBorders");
actionAddBbox->setObjectName("actionAddBbox");
actionRemoveDegenerateFaces->setProperty("subMenuName", "Polygon Mesh Processing/Repair/Experimental");
actionStitchCloseBorderHalfedges->setProperty("subMenuName", "Polygon Mesh Processing/Repair/Experimental");
@ -85,6 +88,7 @@ public:
actionNewAutorefine->setProperty("subMenuName", "Polygon Mesh Processing/Repair");
actionAutorefineAndRMSelfIntersections->setProperty("subMenuName", "Polygon Mesh Processing/Repair/Experimental");
actionSnapBorders->setProperty("subMenuName", "Polygon Mesh Processing/Repair/Experimental");
actionAddBbox->setProperty("subMenuName", "Polygon Mesh Processing");
autoConnectActions();
}
@ -102,7 +106,8 @@ public:
<< actionNewAutorefine
<< actionAutorefineAndRMSelfIntersections
<< actionRemoveNeedlesAndCaps
<< actionSnapBorders;
<< actionSnapBorders
<< actionAddBbox;
}
bool applicable(QAction* action) const
@ -127,6 +132,8 @@ public:
template <typename Item>
void on_actionRemoveDegenerateFaces_triggered(Scene_interface::Item_id index);
template <typename Item>
void on_actionAddBbox_triggered(Scene_interface::Item_id index);
template <typename Item>
void on_actionRemoveSelfIntersections_triggered(Scene_interface::Item_id index);
template <typename Item>
void on_actionStitchCloseBorderHalfedges_triggered(Scene_interface::Item_id index);
@ -156,6 +163,7 @@ public Q_SLOTS:
void on_actionAutorefineAndRMSelfIntersections_triggered();
void on_actionRemoveNeedlesAndCaps_triggered();
void on_actionSnapBorders_triggered();
void on_actionAddBbox_triggered();
private:
QAction* actionRemoveIsolatedVertices;
@ -170,6 +178,7 @@ private:
QAction* actionAutorefineAndRMSelfIntersections;
QAction* actionRemoveNeedlesAndCaps;
QAction* actionSnapBorders;
QAction* actionAddBbox;
Messages_interface* messages;
}; // end Polyhedron_demo_repair_polyhedron_plugin
@ -365,6 +374,41 @@ void Polyhedron_demo_repair_polyhedron_plugin::on_actionSnapBorders_triggered()
sm_item->itemChanged();
}
template<typename Item>
void Polyhedron_demo_repair_polyhedron_plugin::on_actionAddBbox_triggered(Scene_interface::Item_id index)
{
Item* poly_item =
qobject_cast<Item*>(scene->item(index));
if (poly_item)
{
QDialog dialog;
Ui::AddBboxDialog ui;
ui.setupUi(&dialog);
ui.triangulate_bbox->setChecked(true);
ui.bbox_scaling->setValue(1.0);
if(dialog.exec() != QDialog::Accepted)
return;
QApplication::setOverrideCursor(Qt::WaitCursor);
const double scaling = ui.bbox_scaling->value();
CGAL::Polygon_mesh_processing::add_bbox(*poly_item->face_graph(),
CGAL::parameters::bbox_scaling(scaling).
do_not_triangulate_faces(!ui.triangulate_bbox->isChecked()));
poly_item->invalidateOpenGLBuffers();
Q_EMIT poly_item->itemChanged();
QApplication::restoreOverrideCursor();
CGAL::Three::Three::information(tr("Bbox has been added (%1 @%)").arg(scaling));
}
}
void Polyhedron_demo_repair_polyhedron_plugin::on_actionAddBbox_triggered()
{
const Scene_interface::Item_id index = scene->mainSelectionIndex();
on_actionAddBbox_triggered<Scene_surface_mesh_item>(index);
}
template <typename Item>
void Polyhedron_demo_repair_polyhedron_plugin::on_actionRemoveDegenerateFaces_triggered(Scene_interface::Item_id index)
{

1
Polyhedron/package_info/Polyhedron/dependencies
View File

@ -19,6 +19,5 @@ Number_types
Polyhedron
Profiling_tools
Property_map
Random_numbers
STL_Extension
Stream_support

13
Property_map/examples/Property_map/dynamic_properties.cpp
View File

@ -1,6 +1,7 @@
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/boost/graph/generators.h>
#include <string>
@ -14,16 +15,24 @@ int main()
CGAL::make_triangle(Point_3(0,0,0),Point_3(1,0,0),Point_3(1,1,0), mesh);
typedef boost::property_map<Mesh, CGAL::dynamic_vertex_property_t<std::string> >::type VertexNameMap;
VertexNameMap vnm = get(CGAL::dynamic_vertex_property_t<std::string>(), mesh);
VertexNameMap vnm = get(CGAL::dynamic_vertex_property_t<std::string>(), mesh, std::string("default"));
put(vnm, *(vertices(mesh).first), "Paris");
assert(get(vnm, *(vertices(mesh).first))=="Paris");
assert(get(vnm, *(std::next(vertices(mesh).first)))=="default");
std::cout << get(vnm, *(vertices(mesh).first)) << std::endl;
std::cout << get(vnm, *(std::next(vertices(mesh).first))) << std::endl;
typedef boost::property_map<Mesh, CGAL::dynamic_halfedge_property_t<double> >::type TrafficDensityMap;
TrafficDensityMap tdm = get(CGAL::dynamic_halfedge_property_t<double>(), mesh);
TrafficDensityMap tdm = get(CGAL::dynamic_halfedge_property_t<double>(), mesh, -1.);
put(tdm, *(halfedges(mesh).first), 0.7);
assert(get(tdm, *(halfedges(mesh).first))==0.7);
assert(get(tdm, *(std::next(halfedges(mesh).first)))==-1.);
std::cout << get(tdm, *(halfedges(mesh).first)) << std::endl;
std::cout << get(tdm, *(std::next(halfedges(mesh).first))) << std::endl;
return 0;
}

20
Property_map/include/CGAL/Dynamic_property_map.h
View File

@ -135,8 +135,8 @@ struct Dynamic_with_index
: m_values()
{}
Dynamic_with_index(std::size_t num_features)
: m_values( new std::vector<value_type>(num_features) )
Dynamic_with_index(std::size_t num_features, Value default_value = Value())
: m_values( new std::vector<value_type>(num_features, default_value) )
{}
friend reference get(const Dynamic_with_index& m, const key_type& k)
@ -228,34 +228,34 @@ namespace CGAL {
template <typename T, typename G>
typename boost::property_map<G, dynamic_vertex_property_t<T> >::const_type
get(const CGAL::dynamic_vertex_property_t<T>&, const G&)
get(const CGAL::dynamic_vertex_property_t<T>&, const G&, const T& default_value = T())
{
typedef typename boost::graph_traits<G>::vertex_descriptor vertex_descriptor;
return internal::Dynamic_property_map<vertex_descriptor,T>();
return internal::Dynamic_property_map<vertex_descriptor,T>(default_value);
}
template <typename T, typename G>
typename boost::property_map<G, dynamic_halfedge_property_t<T> >::const_type
get(const CGAL::dynamic_halfedge_property_t<T>&, const G&)
get(const CGAL::dynamic_halfedge_property_t<T>&, const G&, const T& default_value = T())
{
typedef typename boost::graph_traits<G>::halfedge_descriptor halfedge_descriptor;
return internal::Dynamic_property_map<halfedge_descriptor,T>();
return internal::Dynamic_property_map<halfedge_descriptor,T>(default_value);
}
template <typename T, typename G>
typename boost::property_map<G, dynamic_edge_property_t<T> >::const_type
get(const CGAL::dynamic_edge_property_t<T>&, const G&)
get(const CGAL::dynamic_edge_property_t<T>&, const G&, const T& default_value = T())
{
typedef typename boost::graph_traits<G>::edge_descriptor edge_descriptor;
return internal::Dynamic_property_map<edge_descriptor,T>();
return internal::Dynamic_property_map<edge_descriptor,T>(default_value);
}
template <typename T, typename G>
typename boost::property_map<G, dynamic_face_property_t<T> >::const_type
get(const CGAL::dynamic_face_property_t<T>&, const G&)
get(const CGAL::dynamic_face_property_t<T>&, const G&, const T& default_value = T())
{
typedef typename boost::graph_traits<G>::face_descriptor face_descriptor;
return internal::Dynamic_property_map<face_descriptor,T>();
return internal::Dynamic_property_map<face_descriptor,T>(default_value);
}
template<typename G, typename Descriptor, typename T>

1
Property_map/test/Property_map/dynamic_properties_test.cpp
View File

@ -2,6 +2,7 @@
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/boost/graph/generators.h>
#if defined(CGAL_USE_OPENMESH)
#include <OpenMesh/Core/IO/MeshIO.hh>

1
Property_map/test/Property_map/kernel_converter_properties_test.cpp
View File

@ -5,6 +5,7 @@
#include <CGAL/MP_Float.h>
#include <CGAL/Cartesian_converter.h>
#include <CGAL/property_map.h>
#include <CGAL/boost/graph/generators.h>
#include <cassert>

1
Ridges_3/package_info/Ridges_3/dependencies
View File

@ -9,7 +9,6 @@ Number_types
Principal_component_analysis_LGPL
Profiling_tools
Property_map
Random_numbers
Ridges_3
STL_Extension
Stream_support

1
SMDS_3/package_info/SMDS_3/dependencies
View File

@ -20,7 +20,6 @@ Number_types
Polygon_mesh_processing
Profiling_tools
Property_map
Random_numbers
SMDS_3
STL_Extension
Spatial_sorting

1
STL_Extension/include/CGAL/STL_Extension/internal/parameters_interface.h
View File

@ -163,6 +163,7 @@ CGAL_add_named_parameter(patch_normal_map_t, patch_normal_map, patch_normal_map)
CGAL_add_named_parameter(region_primitive_map_t, region_primitive_map, region_primitive_map)
CGAL_add_named_parameter(postprocess_regions_t, postprocess_regions, postprocess_regions)
CGAL_add_named_parameter(sizing_function_t, sizing_function, sizing_function)
CGAL_add_named_parameter(bbox_scaling_t, bbox_scaling, bbox_scaling)
// List of named parameters that we use in the package 'Surface Mesh Simplification'
CGAL_add_named_parameter(get_cost_policy_t, get_cost_policy, get_cost)

1
Skin_surface_3/package_info/Skin_surface_3/dependencies
View File

@ -22,7 +22,6 @@ Number_types
Polyhedron
Profiling_tools
Property_map
Random_numbers
STL_Extension
Skin_surface_3
Spatial_sorting

1
Straight_skeleton_extrusion_2/package_info/Straight_skeleton_extrusion_2/dependencies
View File

@ -22,7 +22,6 @@ Polygon
Polygon_mesh_processing
Profiling_tools
Property_map
Random_numbers
STL_Extension
Spatial_sorting
Straight_skeleton_2

1
Subdivision_method_3/package_info/Subdivision_method_3/dependencies
View File

@ -9,7 +9,6 @@ Modular_arithmetic
Number_types
Profiling_tools
Property_map
Random_numbers
STL_Extension
Stream_support
Subdivision_method_3

1
Surface_mesh/examples/Surface_mesh/sm_aabbtree.cpp
View File

@ -6,6 +6,7 @@
#include <CGAL/AABB_face_graph_triangle_primitive.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/boost/graph/Euler_operations.h>
#include <CGAL/boost/graph/generators.h>
typedef CGAL::Simple_cartesian<double> K;
typedef K::Point_3 Point;

32
Surface_mesh/include/CGAL/boost/graph/properties_Surface_mesh.h
View File

@ -353,67 +353,67 @@ namespace CGAL {
// get functions for dynamic properties of mutable Surface_mesh
template <typename Point, typename T>
typename boost::property_map<CGAL::Surface_mesh<Point>, dynamic_vertex_property_t<T> >::type
get(dynamic_vertex_property_t<T>, Surface_mesh<Point>& sm)
get(dynamic_vertex_property_t<T>, Surface_mesh<Point>& sm, const T& default_value = T())
{
typedef typename boost::property_map<Surface_mesh<Point>, dynamic_vertex_property_t<T> >::SMPM SMPM;
typedef typename boost::property_map<Surface_mesh<Point>, dynamic_vertex_property_t<T> >::type DPM;
return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Vertex_index, T>(std::string()).first));
return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Vertex_index, T>(std::string(), default_value).first));
}
template <typename Point, typename T>
typename boost::property_map<Surface_mesh<Point>, dynamic_face_property_t<T> >::type
get(dynamic_face_property_t<T>, Surface_mesh<Point>& sm)
get(dynamic_face_property_t<T>, Surface_mesh<Point>& sm, const T& default_value = T())
{
typedef typename boost::property_map<Surface_mesh<Point>, dynamic_face_property_t<T> >::SMPM SMPM;
typedef typename boost::property_map<Surface_mesh<Point>, dynamic_face_property_t<T> >::type DPM;
return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Face_index, T>(std::string()).first));
return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Face_index, T>(std::string(), default_value).first));
}
template <typename Point, typename T>
typename boost::property_map<Surface_mesh<Point>, dynamic_edge_property_t<T> >::type
get(dynamic_edge_property_t<T>, Surface_mesh<Point>& sm)
get(dynamic_edge_property_t<T>, Surface_mesh<Point>& sm, const T& default_value = T())
{
typedef typename boost::property_map<Surface_mesh<Point>, dynamic_edge_property_t<T> >::SMPM SMPM;
typedef typename boost::property_map<Surface_mesh<Point>, dynamic_edge_property_t<T> >::type DPM;
return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Edge_index, T>(std::string()).first));
return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Edge_index, T>(std::string(), default_value).first));
}
template <typename Point, typename T>
typename boost::property_map<Surface_mesh<Point>, dynamic_halfedge_property_t<T> >::type
get(dynamic_halfedge_property_t<T>, Surface_mesh<Point>& sm)
get(dynamic_halfedge_property_t<T>, Surface_mesh<Point>& sm, const T& default_value = T())
{
typedef typename boost::property_map<Surface_mesh<Point>, dynamic_halfedge_property_t<T> >::SMPM SMPM;
typedef typename boost::property_map<Surface_mesh<Point>, dynamic_halfedge_property_t<T> >::type DPM;
return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Halfedge_index, T>(std::string()).first));
return DPM(sm, new SMPM(sm.template add_property_map<typename Surface_mesh<Point>::Halfedge_index, T>(std::string(), default_value).first));
}
// get functions for dynamic properties of const Surface_mesh
template <typename Point, typename T>
typename boost::property_map<Surface_mesh<Point>, dynamic_vertex_property_t<T> >::const_type
get(dynamic_vertex_property_t<T>, const Surface_mesh<Point>& sm)
get(dynamic_vertex_property_t<T>, const Surface_mesh<Point>& sm, const T& default_value = T())
{
return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Vertex_index, T>(num_vertices(sm));
return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Vertex_index, T>(num_vertices(sm), default_value);
}
template <typename Point, typename T>
typename boost::property_map<Surface_mesh<Point>, dynamic_face_property_t<T> >::const_type
get(dynamic_face_property_t<T>, const Surface_mesh<Point>& sm)
get(dynamic_face_property_t<T>, const Surface_mesh<Point>& sm, const T& default_value = T())
{
return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Face_index, T>(num_faces(sm));
return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Face_index, T>(num_faces(sm), default_value);
}
template <typename Point, typename T>
typename boost::property_map<Surface_mesh<Point>, dynamic_halfedge_property_t<T> >::const_type
get(dynamic_halfedge_property_t<T>, const Surface_mesh<Point>& sm)
get(dynamic_halfedge_property_t<T>, const Surface_mesh<Point>& sm, const T& default_value = T())
{
return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Halfedge_index, T>(num_halfedges(sm));
return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Halfedge_index, T>(num_halfedges(sm), default_value);
}
template <typename Point, typename T>
typename boost::property_map<Surface_mesh<Point>, dynamic_edge_property_t<T> >::const_type
get(dynamic_edge_property_t<T>, const Surface_mesh<Point>& sm)
get(dynamic_edge_property_t<T>, const Surface_mesh<Point>& sm, const T& default_value = T())
{
return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Edge_index, T>(num_edges(sm));
return CGAL::internal::Dynamic_with_index<typename Surface_mesh<Point>::Edge_index, T>(num_edges(sm), default_value);
}
// implementation detail: required by Dynamic_property_map_deleter

1
Surface_mesh/package_info/Surface_mesh/dependencies
View File

@ -13,7 +13,6 @@ Modular_arithmetic
Number_types
Profiling_tools
Property_map
Random_numbers
STL_Extension
Stream_support
Surface_mesh

1
Surface_mesh_approximation/package_info/Surface_mesh_approximation/dependencies
View File

@ -14,7 +14,6 @@ Principal_component_analysis
Principal_component_analysis_LGPL
Profiling_tools
Property_map
Random_numbers
STL_Extension
Solver_interface
Stream_support

1
Surface_mesh_deformation/package_info/Surface_mesh_deformation/dependencies
View File

@ -13,7 +13,6 @@ Modular_arithmetic
Number_types
Profiling_tools
Property_map
Random_numbers
STL_Extension
Solver_interface
Stream_support

1
Surface_mesh_parameterization/package_info/Surface_mesh_parameterization/dependencies
View File

@ -19,7 +19,6 @@ Number_types
Polygon_mesh_processing
Profiling_tools
Property_map
Random_numbers
STL_Extension
Solver_interface
Spatial_sorting

1
Surface_mesh_shortest_path/package_info/Surface_mesh_shortest_path/dependencies
View File

@ -14,7 +14,6 @@ Modular_arithmetic
Number_types
Profiling_tools
Property_map
Random_numbers
STL_Extension
Spatial_searching
Stream_support

1
Surface_mesh_simplification/package_info/Surface_mesh_simplification/dependencies
View File

@ -14,7 +14,6 @@ Modular_arithmetic
Number_types
Profiling_tools
Property_map
Random_numbers
STL_Extension
Spatial_searching
Stream_support

2
Surface_sweep_2/include/CGAL/Surface_sweep_2/Surface_sweep_2_impl.h
View File

@ -15,6 +15,8 @@
#define CGAL_SURFACE_SWEEP_2_IMPL_H
#include <CGAL/license/Surface_sweep_2.h>
#include <set>
#include <vector>
/*! \file
*

1
Tetrahedral_remeshing/package_info/Tetrahedral_remeshing/dependencies
View File

@ -21,7 +21,6 @@ Number_types
Polygon_mesh_processing
Profiling_tools
Property_map
Random_numbers
SMDS_3
STL_Extension
Spatial_searching

1
Tetrahedral_remeshing/test/Tetrahedral_remeshing/test_tetrahedral_remeshing.cpp
View File

@ -7,6 +7,7 @@
#include <CGAL/Tetrahedral_remeshing/Remeshing_triangulation_3.h>
#include <CGAL/tetrahedral_remeshing.h>
#include <CGAL/Tetrahedral_remeshing/tetrahedral_remeshing_io.h>
#include <CGAL/Random.h>
#include <iostream>
#include <fstream>

1
Triangulation_3/demo/Triangulation_3/MainWindow.cpp
View File

@ -137,6 +137,7 @@ void MainWindow::on_actionLoad_Points_triggered()
// update viewer
Q_EMIT( sceneChanged() );
viewer->changed();
}
void MainWindow::on_actionSave_Points_triggered()

1
Triangulation_3/package_info/Triangulation_3/dependencies
View File

@ -20,7 +20,6 @@ Modular_arithmetic
Number_types
Profiling_tools
Property_map
Random_numbers
STL_Extension
Spatial_sorting
Stream_support

1
Weights/include/CGAL/Weights/cotangent_weights.h
View File

@ -17,6 +17,7 @@
#include <CGAL/Weights/utils.h>
#include <CGAL/boost/graph/helpers.h>
#include <CGAL/boost/graph/named_params_helper.h>
#include <CGAL/Kernel_traits.h>
#include <CGAL/Point_2.h>
#include <CGAL/Point_3.h>

1
Weights/package_info/Weights/dependencies
View File

@ -9,7 +9,6 @@ Number_types
Polygon
Profiling_tools
Property_map
Random_numbers
STL_Extension
Stream_support
Weights