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 CGAL-CMake_testsuite-maxGimeno

This commit is contained in:
Maxime Gimeno 2020-08-21 14:40:58 +02:00
parent d558e7f259 3e50ea6081
commit e2eca0150b
227 changed files with 55990 additions and 5197 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.travis.yml
View File

@ -1,5 +1,5 @@
language: cpp
dist: xenial
dist: bionic
sudo: required
git:
depth: 3
@ -58,7 +58,7 @@ install:
- echo "$PWD"
- if [ -n "$TRAVIS_PULL_REQUEST_BRANCH" ] && [ "$PACKAGE" != CHECK ]; then DO_IGNORE=FALSE; for ARG in $(echo "$PACKAGE");do if [ "$ARG" = "Maintenance" ]; then continue; fi; . $PWD/.travis/test_package.sh "$PWD" "$ARG"; echo "DO_IGNORE is $DO_IGNORE"; if [ "$DO_IGNORE" = "FALSE" ]; then break; fi; done; if [ "$DO_IGNORE" = "TRUE" ]; then travis_terminate 0; fi;fi
- /usr/bin/time -f 'Spend time of %C -- %E (real)' bash .travis/install.sh
- export CXX=clang++ CC=clang;
- export CXX=clang++-10 CC=clang-10;
before_script:
- wget -O doxygen_exe https://cgal.geometryfactory.com/~mgimeno/doxygen_exe
- sudo mv doxygen_exe /usr/bin/doxygen

2
.travis/build_package.sh
View File

@ -11,7 +11,7 @@ function mytime {
function build_examples {
mkdir -p build-travis
cd build-travis
mytime cmake -DCGAL_DIR="/usr/local/lib/cmake/CGAL" -DCMAKE_CXX_FLAGS="${CXX_FLAGS}" -DCGAL_BUILD_THREE_DOC=TRUE ..
mytime cmake -DCGAL_DIR="/usr/local/lib/cmake/CGAL" -DCMAKE_CXX_FLAGS="${CXX_FLAGS}" ..
mytime make -j2 VERBOSE=1
}

9
.travis/install.sh
View File

@ -2,14 +2,15 @@
[ -n "$CGAL_DEBUG_TRAVIS" ] && set -x
DONE=0
sudo add-apt-repository ppa:mikhailnov/pulseeffects -y
sudo apt-get update
while [ $DONE = 0 ]
do
DONE=1 && sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install clang zsh \
flex bison cmake graphviz libgmp-dev libmpfr-dev libmpfi-dev zlib1g-dev libeigen3-dev libboost-dev \
libboost-system-dev libboost-program-options-dev libboost-thread-dev libboost-iostreams-dev \
DONE=1 && sudo -E apt-get -yq --no-install-suggests --no-install-recommends --force-yes install clang-10 zsh \
flex bison cmake graphviz libgmp-dev libmpfr-dev libmpfi-dev zlib1g-dev libeigen3-dev \
qtbase5-dev libqt5sql5-sqlite libqt5opengl5-dev qtscript5-dev libqt5svg5-dev qttools5-dev qttools5-dev-tools qml-module-qtgraphicaleffects libopencv-dev mesa-common-dev libmetis-dev libglu1-mesa-dev \
|| DONE=0 && sudo apt-get update
libboost1.72-dev || DONE=0 && sudo apt-get update
done
exit 0

4
.travis/template.txt
View File

@ -1,5 +1,5 @@
language: cpp
dist: xenial
dist: bionic
sudo: required
git:
depth: 3
@ -12,7 +12,7 @@ install:
- echo "$PWD"
- if [ -n "$TRAVIS_PULL_REQUEST_BRANCH" ] && [ "$PACKAGE" != CHECK ]; then DO_IGNORE=FALSE; for ARG in $(echo "$PACKAGE");do if [ "$ARG" = "Maintenance" ]; then continue; fi; . $PWD/.travis/test_package.sh "$PWD" "$ARG"; echo "DO_IGNORE is $DO_IGNORE"; if [ "$DO_IGNORE" = "FALSE" ]; then break; fi; done; if [ "$DO_IGNORE" = "TRUE" ]; then travis_terminate 0; fi;fi
- /usr/bin/time -f 'Spend time of %C -- %E (real)' bash .travis/install.sh
- export CXX=clang++ CC=clang;
- export CXX=clang++-10 CC=clang-10;
before_script:
- wget -O doxygen_exe https://cgal.geometryfactory.com/~mgimeno/doxygen_exe
- sudo mv doxygen_exe /usr/bin/doxygen

3
AABB_tree/include/CGAL/AABB_halfedge_graph_segment_primitive.h
View File

@ -126,7 +126,7 @@ public:
/*!
Id type:
- `boost::graph_traits<HalfedgeGraph>::%edge_descriptor` if `OneHalfedgeGraphPerTree` is `Tag_true`
- `std::pair<boost::graph_traits<HalfedgeGraph>::edge_descriptor, const HalfedgeGraph*>` if `OneHalfedgeGraphPerTree` is `Tag_false`
- `std::pair<boost::graph_traits<HalfedgeGraph>::%edge_descriptor, const HalfedgeGraph*>` if `OneHalfedgeGraphPerTree` is `Tag_false`
*/
unspecified_type Id;
/// @}
@ -202,4 +202,3 @@ public:
#include <CGAL/enable_warnings.h>
#endif // CGAL_AABB_HALFEDGE_GRAPH_SEGMENT_PRIMITIVE_H

6
AABB_tree/include/CGAL/AABB_traits.h
View File

@ -171,9 +171,11 @@ class AABB_tree;
/// \sa `AABBPrimitiveWithSharedData`
template<typename GeomTraits, typename AABBPrimitive, typename BboxMap = Default>
class AABB_traits:
public internal::AABB_tree::AABB_traits_base<AABBPrimitive>,
class AABB_traits
#ifndef DOXYGEN_RUNNING
: public internal::AABB_tree::AABB_traits_base<AABBPrimitive>,
public internal::AABB_tree::AABB_traits_base_2<GeomTraits>
#endif
{
typedef typename CGAL::Object Object;
public:

2
Advancing_front_surface_reconstruction/examples/Advancing_front_surface_reconstruction/reconstruction_surface_mesh.cpp
View File

@ -1,10 +1,10 @@
#include <iostream>
#include <fstream>
#include <algorithm>
#include <array>
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Advancing_front_surface_reconstruction.h>
#include <CGAL/Surface_mesh.h>
#include <CGAL/array.h>
#include <CGAL/disable_warnings.h>
typedef std::array<std::size_t,3> Facet;

20
Arrangement_on_surface_2/include/CGAL/Arr_geometry_traits/Bezier_cache.h
View File

@ -653,7 +653,7 @@ void _Bezier_cache<NtTraits>::_self_intersection_params
// II: Y(t) - Y(s) / (t - s) = 0
//
Integer *coeffs;
int i, k;
int i;
// Consruct the bivariate polynomial that corresponds to Equation I.
// Note that we represent a bivariate polynomial as a vector of univariate
@ -667,12 +667,11 @@ void _Bezier_cache<NtTraits>::_self_intersection_params
coeffs = new Integer [degX];
for (i = 0; i < degX; i++)
{
for (k = i + 1; k < degX; k++)
coeffs[k - i - 1] = nt_traits.get_coefficient (polyX, k);
coeffs[i] = nt_traits.get_coefficient(polyX, i + 1);
coeffsX_st[i] = nt_traits.construct_polynomial (coeffs, degX - i - 1);
}
for (i = 0; i < degX; i++)
coeffsX_st[degX - i - 1] =
nt_traits.construct_polynomial(coeffs + i, degX - i - 1);
delete[] coeffs;
@ -685,12 +684,11 @@ void _Bezier_cache<NtTraits>::_self_intersection_params
coeffs = new Integer [degY];
for (i = 0; i < degY; i++)
{
for (k = i + 1; k < degY; k++)
coeffs[k - i - 1] = nt_traits.get_coefficient (polyY, k);
coeffs[i] = nt_traits.get_coefficient(polyY, i + 1);
coeffsY_st[i] = nt_traits.construct_polynomial (coeffs, degY - i - 1);
}
for (i = 0; i < degY; i++)
coeffsY_st[degY - i - 1] =
nt_traits.construct_polynomial(coeffs + i, degY - i - 1);
delete[] coeffs;

34
Arrangement_on_surface_2/include/CGAL/Arr_geometry_traits/Bezier_point_2.h
View File

@ -1641,17 +1641,43 @@ void _Bezier_point_2_rep<RatKer, AlgKer, NtTrt, BndTrt>::_make_exact
const Algebraic t_min = nt_traits.convert (orig2.point_bound().t_min);
const Algebraic t_max = nt_traits.convert (orig2.point_bound().t_max);
bool self_intersecting = (org_it1->curve().id() == org_it2->curve().id());
for (intr_it = intr_list.begin(); intr_it != intr_list.end(); ++intr_it)
{
if (CGAL::compare (intr_it->s, s_min) != SMALLER &&
CGAL::compare (intr_it->s, s_max) != LARGER &&
CGAL::compare (intr_it->t, t_min) != SMALLER &&
CGAL::compare (intr_it->t, t_max) != LARGER)
auto in_bounding_interval =
[](const auto& s_, const auto& s_min_, const auto& s_max_) -> bool {
return CGAL::compare(s_, s_min_) != SMALLER &&
CGAL::compare(s_, s_max_) != LARGER;
};
bool st_in_st_range = in_bounding_interval(intr_it->s, s_min, s_max) &&
in_bounding_interval(intr_it->t, t_min, t_max);
bool ts_in_st_range = false;
if (st_in_st_range)
{
// Update the originators.
orig1.set_parameter(intr_it->s);
orig2.set_parameter(intr_it->t);
}
else if (self_intersecting)
{
// check whether s is in t range, and t is in s range
// s and t can be interchanged in case of self intersections
ts_in_st_range = in_bounding_interval(intr_it->t, s_min, s_max) &&
in_bounding_interval(intr_it->s, t_min, t_max);
if (ts_in_st_range)
{
// Update the originators.
orig1.set_parameter(intr_it->t);
orig2.set_parameter(intr_it->s);
}
}
if (st_in_st_range || ts_in_st_range)
{
// Set the exact point coordinates.
p_alg_x = new Algebraic (intr_it->x);
p_alg_y = new Algebraic (intr_it->y);

3
Arrangement_on_surface_2/include/CGAL/Arr_geometry_traits/Bezier_x_monotone_2.h
View File

@ -1139,10 +1139,11 @@ _Bezier_x_monotone_2<RatKer, AlgKer, NtTrt, BndTrt>::compare_to_left
Originator_iterator org = p.get_originator(_curve, _xid);
CGAL_assertion(org != p.originators_end());
CGAL_assertion(_inc_to_right != cv._inc_to_right);
if (org->point_bound().type == Bez_point_bound::VERTICAL_TANGENCY_PT)
{
CGAL_assertion(_inc_to_right != cv._inc_to_right);
if (! p.is_exact())
{
// Comparison based on the control polygon of the bounded vertical

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

@ -27,18 +27,6 @@ EXAMPLE_PATH = ${CGAL_Surface_mesh_skeletonization_EXAMPLE_DIR} \
ALIASES += "bgllink{1}=<a href=\"http://www.boost.org/libs/graph/doc/\1.html\"><code>\1</code></a>"
# macros to be used inside the code
ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref BGL_\1 \"\1\"</td><td>"
ALIASES += "cgalParamEnd=</td></tr>"
#macros for NamedParameters.txt
ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
ALIASES += "cgalNPEnd=</td></tr>"
EXTRACT_ALL=NO
HIDE_UNDOC_MEMBERS = YES
HIDE_UNDOC_CLASSES = YES

214
BGL/doc/BGL/NamedParameters.txt
View File

@ -1,8 +1,8 @@
/*!
\defgroup bgl_namedparameters BGL Named Parameters
\defgroup bgl_namedparameters Named Parameters
\ingroup PkgBGLRef
The algorithms of the \sc{Bgl} often have many parameters with default
The algorithms of the Boost Graph Library (\sc{Bgl}) often have many parameters with default
values that are appropriate for most cases. In general, when no
special treatment is applied, the values of such parameters are passed
as a sequence. Deviating from the default for a certain parameter
@ -20,200 +20,26 @@ dijkstra_shortest_paths(g, s, predecessor_map(&p[0]).distance_map(&d[0]));
In the \sc{Bgl} manual, this is called
<a href="https://www.boost.org/libs/graph/doc/bgl_named_params.html">named parameters</a>.
The named parameters in the example use the tags `predecessor_map` and `distance_map`
and they are concatenated with the dot operator.<BR>
The named parameters in the snippet use the tags `predecessor_map` and `distance_map`
and they are concatenated using the dot operator.<BR>
In the following, we assume that `PolygonMesh` is a model of the concept `FaceGraph`.
Note that for some functions, the type might be more specific:
A similar mechanism was introduced in \cgal, with the small difference that the named parameters
tag live in the `CGAL::parameters::` namespace and `CGAL::parameters::all_default()` can be used to indicate
that default values of optional named parameters must be used.
As in the \sc{BGL}, named parameters in \cgal are also concatenated using
the dot operator, and a typical usage is thus:
Here is the list of the named parameters available in this package:
\code {.cpp}
Graph g1, g2;
Vertex_point_map_2 vpm_2; // an hypothetical custom property map assigning a Point to the vertices of g2
\cgalNPTableBegin
\cgalNPBegin{vertex_point_map} \anchor BGL_vertex_point_map
is the property map with the points associated to the vertices of the polygon mesh.\n
<b>Type:</b> a class model of `ReadablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type and
a \cgal point type as value type. \n
<b>Default:</b> \code boost::get(CGAL::vertex_point, pmesh) \endcode
\cgalNPEnd
\cgalNPBegin{vertex_index_map} \anchor BGL_vertex_index_map
is the property map associating a unique index to each vertex of a polygon mesh `g`,
between `0` and `num_vertices(g)-1`.
If this parameter is not passed, internal machinery will create and initialize a vertex index
property map, either using the internal property map if it exists or using an external map. The latter
might result in - slightly - worsened performance in case of non-constant complexity for index access.\n
<b>Type:</b> a class model of `ReadablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type and the value type
\code typename boost::property_traits<typename boost::property_map<PolygonMesh, CGAL::vertex_index_t>::type>::value_type \endcode
<b>Default:</b> an initialized vertex index property map
\cgalNPEnd
\cgalNPBegin{halfedge_index_map} \anchor BGL_halfedge_index_map
is the property map associating a unique index to each halfedge of a polygon mesh,
between `0` and `num_halfedges(g)-1`.
If this parameter is not passed, internal machinery will create and initialize a halfedge index
property map, either using the internal property map if it exists or using an external map. The latter
might result in - slightly - worsened performance in case of non-constant complexity for index access.\n
<b>Type:</b> a class model of `ReadablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%halfedge_descriptor` as key type and the value type:
\code typename boost::property_traits<typename boost::property_map<PolygonMesh, CGAL::halfedge_index_t>::type>::value_type \endcode
<b>Default:</b> an initialized halfedge index property map
\cgalNPEnd
\cgalNPBegin{edge_index_map} \anchor BGL_edge_index_map
is the property map associating a unique index to each edge of a polygon mesh,
between `0` and `num_edges(g)-1`.
If this parameter is not passed, internal machinery will create and initialize a edge index
property map, either using the internal property map if it exists or using an external map. The latter
might result in - slightly - worsened performance in case of non-constant complexity for index access.\n
<b>Type:</b> a class model of `ReadablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%edge_descriptor` as key type and the value type:
\code typename boost::property_traits<typename boost::property_map<PolygonMesh, CGAL::edge_index_t>::type>::value_type \endcode
<b>Default:</b> an initialized edge index property map
\cgalNPEnd
\cgalNPBegin{face_index_map} \anchor BGL_face_index_map
is the property map associating a unique index to each face of a polygon mesh,
between `0` and `num_faces(g)-1`.
If this parameter is not passed, internal machinery will create and initialize a face index
property map, either using the internal property map if it exists or using an external map. The latter
might result in - slightly - worsened performance in case of non-constant complexity for index access.\n
<b>Type:</b> a class model of `ReadablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and the value type:
\code typename boost::property_traits<typename boost::property_map<PolygonMesh, CGAL::face_index_t>::type>::value_type \endcode
<b>Default:</b> an initialized face index property map
\cgalNPEnd
\cgalNPBegin{edge_is_constrained_map} \anchor BGL_edge_is_constrained_map
is the property map containing information about edges of the input polygon mesh
being marked or not.\n
<b>Type:</b> a class model of `ReadWritePropertyMap` with
`boost::graph_traits<PolygonMesh>::%edge_descriptor` as key type and
`bool` as value type. It should be default constructible.\n
<b>Default:</b> a default property map where no edge is constrained
\cgalNPEnd
\cgalNPBegin{use_binary_mode} \anchor BGL_use_binary_mode
is a Boolean indicating whether the binary mode or the ASCII mode should be used
when writing data into a stream.\n
<b>Type:</b> `bool`\n
<b>Default:</b> Function specific.
\cgalNPEnd
\cgalNPBegin{METIS_options} \anchor BGL_METIS_options
is a parameter used in `partition_graph()` and `partition_dual_graph()`
to pass options to the METIS graph partitioner. The many options of METIS
are not described here. Instead, users should refer to METIS'
<a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>.\n
<b>Type:</b> an array of size `METIS_NOPTIONS` with value type `idx_t`
(an integer type defined by METIS). \n
<b>Default:</b> an array of size `METIS_NOPTIONS` with value type `idx_t`,
initialized using the function `METIS_SetDefaultOptions()`.
\cgalNPEnd
\cgalNPBegin{vertex_partition_id_map} \anchor BGL_vertex_partition_id_map
is the property map storing for each vertex of the mesh the id of the subpart
of the partition that has been assigned to this vertex.\n
<b>Type:</b> a class model of `ReadWritePropertyMap` with
`boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type and
`int` as value type. \n
<b>Default:</b> None: this property map is used to store the partition IDs of the vertices
as result of a partition algorithm; if it is not provided, this information is
simply inaccessible.
\cgalNPEnd
\cgalNPBegin{face_partition_id_map} \anchor BGL_face_partition_id_map
is the property map storing for each face of the mesh the id of the subpart
of the partition that has been assigned to this face.\n
<b>Type:</b> a class model of `ReadWritePropertyMap` with
`boost::graph_traits<PolygonMesh>::%face_descriptor` as key type and
`int` as value type. \n
<b>Default:</b> None: this property map is used to store the partition IDs of the faces
as result of a partition algorithm; if it is not provided, this information is
simply inaccessible.
\cgalNPEnd
\cgalNPBegin{vertex_to_vertex_output_iterator} \anchor BGL_vertex_to_vertex_output_iterator
is a model of `OutputIterator` accepting `std::pair<vertex_descriptor, vertex_descriptor>`
A typical use case is mapping the vertices from a source mesh to its copy's after a `copy_face_graph()`
operation.\n
<b>Type:</b>a class model of `OutputIterator` accepting
`std::pair<`boost::graph_traits<PolygonMesh>::%vertex_descriptor, `boost::graph_traits<PolygonMesh>::%vertex_descriptor>`.\n
<b>Default:</b> Emptyset_iterator
\cgalNPEnd
\cgalNPBegin{halfedge_to_halfedge_output_iterator} \anchor BGL_halfedge_to_halfedge_output_iterator
is a model of `OutputIterator` accepting `std::pair<halfedge_descriptor, halfedge_descriptor>`
A typical use case is mapping the halfedges from a source mesh to its copy's after a `copy_face_graph()`
operation.\n
<b>Type:</b>a class model of `OutputIterator` accepting
`std::pair<`boost::graph_traits<PolygonMesh>::%halfedge_descriptor, `boost::graph_traits<PolygonMesh>::%halfedge_descriptor>`.\n
<b>Default:</b> Emptyset_iterator
\cgalNPEnd
\cgalNPBegin{face_to_face_output_iterator} \anchor BGL_face_to_face_output_iterator
is a model of `OutputIterator` accepting `std::pair<face_descriptor, face_descriptor>`
A typical use case is mapping the faces from a source mesh to its copy's after a `copy_face_graph()`
operation.\n
<b>Type:</b>a class model of `OutputIterator` accepting
`std::pair<`boost::graph_traits<PolygonMesh>::%face_descriptor, `boost::graph_traits<PolygonMesh>::%face_descriptor>`.\n
<b>Default:</b> Emptyset_iterator
\cgalNPEnd
\cgalNPBegin{vertex_to_vertex_map} \anchor BGL_vertex_to_vertex_map
is a property map storing for each vertex of a source mesh the corresponding vertex of another mesh.\n
A typical use case is mapping the vertices from a source mesh to its copy's after a `copy_face_graph()`
operation.\n
<b>Type:</b>a class model of `ReadWritePropertyMap` with
`boost::graph_traits<PolygonMesh1>::%vertex_descriptor` as key type and
`boost::graph_traits<PolygonMesh2>::%vertex_descriptor` as value type.\n
<b>Default:</b> None.
\cgalNPEnd
\cgalNPBegin{halfedge_to_halfedge_map} \anchor BGL_halfedge_to_halfedge_map
is a property map storing for each halfedge of a source mesh the corresponding halfedge of another mesh.\n
A typical use case is mapping the vertices from a source mesh to its copy's after a `copy_face_graph()`
operation.\n
<b>Type:</b>a class model of `ReadWritePropertyMap` with
`boost::graph_traits<PolygonMesh1>::%halfedge_descriptor` as key type and
`boost::graph_traits<PolygonMesh2>::%halfedge_descriptor` as value type.\n
<b>Default:</b> None.
\cgalNPEnd
\cgalNPBegin{face_to_face_map} \anchor BGL_face_to_face_map
is a property map storing for each face of a source mesh the corresponding face of another mesh.\n
A typical use case is mapping the vertices from a source mesh to its copy's after a `copy_face_graph()`
operation.\n
<b>Type:</b>a class model of `ReadWritePropertyMap` with
`boost::graph_traits<PolygonMesh1>::%face_descriptor` as key type and
`boost::graph_traits<PolygonMesh2>::%face_descriptor` as value type.\n
<b>Default:</b> None.
\cgalNPEnd
\cgalNPBegin{implementation_tag} \anchor BGL_implementation_tag
tag used to select the implementation to be used among an algorithm-specific list.\n
<b>Type:</b>a tag class\n
<b>Default:</b> algorithm-specific.
\cgalNPEnd
\cgalNPBegin{prevent_unselection} \anchor BGL_prevent_unselection
Boolean used to indicate if selection can be only extended or if it can also be shrinked.\n
<b>Type:</b> `bool`\n
<b>Default:</b> `false`.
\cgalNPEnd
\cgalNPBegin{geom_traits} \anchor BGL_geom_traits
is the geometric traits instance used.\n
<b>Type:</b> a Geometric traits class.\n
<b>Default</b>:
\code typename CGAL::Kernel_traits<
typename boost::property_traits<
typename boost::property_map<FaceGraph, CGAL::vertex_point_t>::type>::value_type>::Kernel \endcode
\cgalNPEnd
\cgalNPTableEnd
// without any named parameter (default values are used)
CGAL::copy_face_graph(g1, g2);
// specifying named parameters for the second graph
CGAL::copy_face_graph(g1, g2,
CGAL::parameters::all_default(),
CGAL::parameters::vertex_point_map(vpm_2));
\endcode
*/
˛

6
BGL/include/CGAL/boost/graph/Dual.h
View File

@ -56,18 +56,18 @@ public:
/*! The underlying primal type. */
typedef Primal_ Primal;
/*! Construct a Dual from a given primal. */
/*! constructs a Dual from a given primal. */
Dual(const Primal& primal)
: primal_(primal) {}
/*! Returns the underlying primal. */
/*! returns the underlying primal. */
const Primal& primal() const
{ return primal_; }
};
/*!
Construct a `Dual` from a given `primal`.
constructs a `Dual` from a given `primal`.
\relates CGAL::Dual
*/
template<typename Primal>

148
BGL/include/CGAL/boost/graph/Face_filtered_graph.h
View File

@ -113,22 +113,44 @@ struct Face_filtered_graph
* \tparam FacePatchIndexRange a model of `ConstRange` with `boost::property_traits<FacePatchIndexMap>::%value_type` as value type.
* \tparam NamedParameters a sequence of named parameters
*
* \param graph the underlying graph.
* \param face_patch_index_map the property_map that assigns a patch index to each face, with
`face_descriptor` as key type and `boost::graph_traits<Graph>::%faces_size_type` as value type.
* \param selected_face_patch_indices a range of the face patch indices to select.
* \param np optional sequence of named parameters among the ones listed below
* \param graph the underlying graph
* \param face_patch_index_map the property_map that assigns a patch index to each face
* \param selected_face_patch_indices a range of the face patch indices to select
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{face_index_map}
* a property map containing for each face of `graph` a unique index between `0` and `num_faces(graph)-1`
* \cgalParamEnd
* \cgalParamBegin{vertex_index_map}
* a property map containing for each vertex of `graph` a unique index between `0` and `num_vertices(graph)-1`
* \cgalParamEnd
* \cgalParamBegin{halfedge_index_map}
* a property map containing for each halfedge of `graph` a unique index between `0` and `num_halfedges(graph)-1`
* \cgalParamEnd
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `graph` a unique index between `0` and `num_vertices(graph) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
* a face index property map, either using the internal property map if it exists
* or using an external map. The latter might result in - slightly - worsened performance
* in case of non-constant complexity for index access.}
* \cgalParamNEnd
*
* \cgalParamNBegin{halfedge_index_map}
* \cgalParamDescription{a property map associating to each halfedge of `graph` a unique index between `0` and `num_halfedges(graph) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%halfedge_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
* a face index property map, either using the internal property map if it exists
* or using an external map. The latter might result in - slightly - worsened performance
* in case of non-constant complexity for index access.}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `graph` a unique index between `0` and `num_faces(graph) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
* a face index property map, either using the internal property map if it exists
* or using an external map. The latter might result in - slightly - worsened performance
* in case of non-constant complexity for index access.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <typename FacePatchIndexMap, class FacePatchIndexRange, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
@ -172,23 +194,45 @@ struct Face_filtered_graph
`face_descriptor` as key type and
`graph_traits<Graph>::%faces_size_type` as value type.
* \tparam NamedParameters a sequence of named parameters
*
* \param graph the underlying graph.
* \param face_patch_index_map the property_map that assigns a patch index to each face, with
`face_descriptor` as key type and
`graph_traits<Graph>::%faces_size_type` as value type.
* \param selected_face_patch_index the index of the face patch selected.
* \param np optional sequence of named parameters among the ones listed below
* \param face_patch_index_map the property_map that assigns a patch index to each face
* \param selected_face_patch_index the index of the face patch selected
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{face_index_map}
* a property map containing for each face of `graph` a unique index between `0` and `num_faces(graph)-1`
* \cgalParamEnd
* \cgalParamBegin{vertex_index_map}
* a property map containing for each vertex of `graph` a unique index between `0` and `num_vertices(graph)-1`
* \cgalParamEnd
* \cgalParamBegin{halfedge_index_map}
* a property map containing for each halfedge of `graph` a unique index between `0` and `num_halfedges(graph)-1`
* \cgalParamEnd
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `graph` a unique index between `0` and `num_vertices(graph) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
* a face index property map, either using the internal property map if it exists
* or using an external map. The latter might result in - slightly - worsened performance
* in case of non-constant complexity for index access.}
* \cgalParamNEnd
*
* \cgalParamNBegin{halfedge_index_map}
* \cgalParamDescription{a property map associating to each halfedge of `graph` a unique index between `0` and `num_halfedges(graph) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%halfedge_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
* a face index property map, either using the internal property map if it exists
* or using an external map. The latter might result in - slightly - worsened performance
* in case of non-constant complexity for index access.}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `graph` a unique index between `0` and `num_faces(graph) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
* a face index property map, either using the internal property map if it exists
* or using an external map. The latter might result in - slightly - worsened performance
* in case of non-constant complexity for index access.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <typename FacePatchIndexMap, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>
@ -221,20 +265,44 @@ struct Face_filtered_graph
*
* \tparam FaceRange a model of `ConstRange` with `face_descriptor` as value type.
* \tparam NamedParameters a sequence of named parameters
* \param graph the graph containing the wanted patch.
* \param selected_faces the set of selected faces.
* \param np optional sequence of named parameters among the ones listed below
*
* \param graph the graph containing the wanted patch
* \param selected_faces the set of selected faces
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{face_index_map}
* a property map containing an index for each face initialized from 0 to `num_vertices(graph)`
* \cgalParamEnd
* \cgalParamBegin{vertex_index_map}
* a property map containing an index for each vertex initialized 0 to `num_vertices(graph)`
* \cgalParamEnd
* \cgalParamBegin{halfedge_index_map}
* a property map containing an index for each halfedge initialized 0 to `num_halfedges(graph)`
* \cgalParamEnd
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `graph` a unique index between `0` and `num_vertices(graph) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
* a face index property map, either using the internal property map if it exists
* or using an external map. The latter might result in - slightly - worsened performance
* in case of non-constant complexity for index access.}
* \cgalParamNEnd
*
* \cgalParamNBegin{halfedge_index_map}
* \cgalParamDescription{a property map associating to each halfedge of `graph` a unique index between `0` and `num_halfedges(graph) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%halfedge_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
* a face index property map, either using the internal property map if it exists
* or using an external map. The latter might result in - slightly - worsened performance
* in case of non-constant complexity for index access.}
* \cgalParamNEnd
*
* \cgalParamNBegin{face_index_map}
* \cgalParamDescription{a property map associating to each face of `graph` a unique index between `0` and `num_faces(graph) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<Graph>::%face_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
* a face index property map, either using the internal property map if it exists
* or using an external map. The latter might result in - slightly - worsened performance
* in case of non-constant complexity for index access.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template <typename FaceRange, class CGAL_BGL_NP_TEMPLATE_PARAMETERS>

61
BGL/include/CGAL/boost/graph/METIS/partition_dual_graph.h
View File

@ -129,35 +129,56 @@ void partition_dual_graph(const TriangleMesh& tm, int nparts,
/// \ingroup PkgBGLPartition
///
/// Computes a partition of the input triangular mesh into `nparts` parts,
/// computes a partition of the input triangular mesh into `nparts` parts,
/// based on the mesh's dual graph. The resulting partition is stored in the vertex and/or face
/// property maps that are passed as parameters using \ref bgl_namedparameters "Named Parameters".
///
/// \param tm a triangle mesh
/// \param nparts the number of parts in the final partition
/// \param np optional \ref bgl_namedparameters "Named Parameters" described below
/// \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
///
/// \tparam TriangleMesh is a model of the `FaceListGraph` concept.
/// \tparam TriangleMesh is a model of the `FaceListGraph` concept
/// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_index_map}
/// is a property map containing for each vertex of `tm` a unique index between `0` and `num_vertices(tm)-1`.
/// \cgalParamEnd
/// \cgalParamBegin{METIS_options}
/// is a parameter used in to pass options to the METIS mesh
/// partitioner. The many options of METIS are not described here. Instead, users
/// should refer to the <a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>
/// of METIS directly.
/// \cgalParamEnd
/// \cgalParamBegin{vertex_partition_id_map}
/// is a property map that contains (after the function has been run)
/// the ID of the subpart for each vertex of `tm`.
/// \cgalParamEnd
/// \cgalParamBegin{face_partition_id_map}
/// is a property map that contains (after the function has been run)
/// the ID of the subpart for each face of `tm`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_index_map}
/// \cgalParamDescription{a property map associating to each vertex of `tm` a unique index between `0` and `num_vertices(tm) - 1`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `std::size_t` as value type}
/// \cgalParamDefault{an automatically indexed internal map}
/// \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
/// a face index property map, either using the internal property map if it exists
/// or using an external map. The latter might result in - slightly - worsened performance
/// in case of non-constant complexity for index access.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{METIS_options}
/// \cgalParamDescription{a parameter used in to pass options to the METIS mesh partitioner}
/// \cgalParamType{an array of size `METIS_NOPTIONS` with value type `idx_t` (an integer type defined by METIS)}
/// \cgalParamDefault{an array of size `METIS_NOPTIONS` with value type `idx_t`,
/// initialized using the function `METIS_SetDefaultOptions()`}
/// \cgalParamExtra{The many options of METIS are not described here. Instead, users should refer
/// to the <a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>
/// of METIS directly.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{vertex_partition_id_map}
/// \cgalParamDescription{a property map that contains (after the function has been run)
/// the ID of the subpart for each vertex of `tm`}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with
/// `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and
/// `int` as value type}
/// \cgalParamDefault{unused}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{face_partition_id_map}
/// \cgalParamDescription{a property map that contains (after the function has been run)
/// the ID of the subpart for each face of `tm`}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with
/// `boost::graph_traits<TriangleMesh>::%face_descriptor` as key type and
/// `int` as value type}
/// \cgalParamDefault{unused}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \pre `tm` is a pure triangular surface mesh: there are no edges

59
BGL/include/CGAL/boost/graph/METIS/partition_graph.h
View File

@ -161,35 +161,56 @@ void partition_graph(const TriangleMesh& tm, int nparts,
/// \ingroup PkgBGLPartition
///
/// Computes a partition of the input triangular mesh into `nparts` parts, based on the
/// computes a partition of the input triangular mesh into `nparts` parts, based on the
/// mesh's nodal graph. The resulting partition is stored in the vertex and/or face
/// property maps that are passed as parameters using \ref bgl_namedparameters "Named Parameters".
///
/// \param tm a triangle mesh
/// \param nparts the number of parts in the final partition
/// \param np optional \ref bgl_namedparameters "Named Parameters" described below
/// \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
///
/// \tparam TriangleMesh is a model of the `FaceListGraph` concept.
/// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_index_map}
/// is a property map containing for each vertex of `tm` a unique index between `0` and `num_vertices(tm)-1`.
/// \cgalParamEnd
/// \cgalParamBegin{METIS_options}
/// is a parameter used in to pass options to the METIS mesh
/// partitioner. The many options of METIS are not described here. Instead, users
/// should refer to the <a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>
/// of METIS directly.
/// \cgalParamEnd
/// \cgalParamBegin{vertex_partition_id_map}
/// is a property map that contains (after the function has been run)
/// the ID of the subpart for each vertex of `tm`.
/// \cgalParamEnd
/// \cgalParamBegin{face_partition_id_map}
/// is a property map that contains (after the function has been run)
/// the ID of the subpart for each face of `tm`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_index_map}
/// \cgalParamDescription{a property map associating to each vertex of `tm` a unique index between `0` and `num_vertices(tm) - 1`}
/// \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
/// as key type and `std::size_t` as value type}
/// \cgalParamDefault{an automatically indexed internal map}
/// \cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
/// a face index property map, either using the internal property map if it exists
/// or using an external map. The latter might result in - slightly - worsened performance
/// in case of non-constant complexity for index access.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{METIS_options}
/// \cgalParamDescription{a parameter used in to pass options to the METIS mesh partitioner}
/// \cgalParamType{an array of size `METIS_NOPTIONS` with value type `idx_t` (an integer type defined by METIS)}
/// \cgalParamDefault{an array of size `METIS_NOPTIONS` with value type `idx_t`,
/// initialized using the function `METIS_SetDefaultOptions()`}
/// \cgalParamExtra{The many options of METIS are not described here. Instead, users should refer
/// to the <a href="http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf">documentation</a>
/// of METIS directly.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{vertex_partition_id_map}
/// \cgalParamDescription{a property map that contains (after the function has been run)
/// the ID of the subpart for each vertex of `tm`}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with
/// `boost::graph_traits<TriangleMesh>::%vertex_descriptor` as key type and
/// `int` as value type}
/// \cgalParamDefault{unused}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{face_partition_id_map}
/// \cgalParamDescription{a property map that contains (after the function has been run)
/// the ID of the subpart for each face of `tm`}
/// \cgalParamType{a class model of `ReadWritePropertyMap` with
/// `boost::graph_traits<TriangleMesh>::%face_descriptor` as key type and
/// `int` as value type}
/// \cgalParamDefault{unused}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
/// \pre `tm` is a pure triangular surface mesh: there are no edges

66
BGL/include/CGAL/boost/graph/Seam_mesh.h
View File

@ -168,7 +168,7 @@ private:
mutable vertices_size_type number_of_vertices;
public:
/// Returns the underlying mesh.
/// returns the underlying mesh.
const TM& mesh() const
{
return tm;
@ -543,31 +543,31 @@ public:
/// \name Seam query functions
/// @{
/// Returns `true` if the vertex is on the seam.
/// returns `true` if the vertex is on the seam.
bool has_on_seam(TM_vertex_descriptor vd) const
{
return get(svm, vd);
}
/// Returns `true` if the edge is on the seam.
/// returns `true` if the edge is on the seam.
bool has_on_seam(TM_edge_descriptor ed) const
{
return get(sem, ed);
}
/// Returns `true` if the halfedge is on the seam.
/// returns `true` if the halfedge is on the seam.
bool has_on_seam(TM_halfedge_descriptor tmhd) const
{
return get(sem, CGAL::edge(tmhd, tm));
}
/// Returns `true` if the halfedge is on the seam.
/// returns `true` if the halfedge is on the seam.
bool has_on_seam(const halfedge_descriptor& hd) const
{
return has_on_seam(CGAL::edge(hd, tm));
}
/// Return the number of seam edges in the seam mesh.
/// returns the number of seam edges in the seam mesh.
edges_size_type number_of_seam_edges() const
{
return number_of_seams;
@ -601,7 +601,7 @@ public:
}
/// @endcond
/// Returns the iterator range of the vertices of the mesh.
/// returns the iterator range of the vertices of the mesh.
Iterator_range<vertex_iterator> vertices() const
{
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
@ -627,7 +627,7 @@ public:
}
/// @endcond
/// Returns the iterator range of the halfedges of the mesh.
/// returns the iterator range of the halfedges of the mesh.
Iterator_range<halfedge_iterator> halfedges() const
{
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
@ -652,7 +652,7 @@ public:
}
/// @endcond
/// Returns the iterator range of the edges of the mesh.
/// returns the iterator range of the edges of the mesh.
Iterator_range<edge_iterator> edges() const
{
Iterator_range<TM_halfedge_iterator> ir = CGAL::halfedges(tm);
@ -675,7 +675,7 @@ public:
}
/// @endcond
/// Returns the iterator range of the faces of the mesh.
/// returns the iterator range of the faces of the mesh.
Iterator_range<face_iterator> faces() const
{
return CGAL::faces(tm);
@ -686,7 +686,7 @@ public:
/// \name Memory Management
/// @{
/// Returns the number of vertices in the seam mesh.
/// returns the number of vertices in the seam mesh.
vertices_size_type num_vertices() const
{
if(number_of_vertices == static_cast<vertices_size_type>(-1)) {
@ -696,19 +696,19 @@ public:
return number_of_vertices;
}
/// Returns the number of halfedges in the seam mesh.
/// returns the number of halfedges in the seam mesh.
halfedges_size_type num_halfedges() const
{
return CGAL::num_halfedges(tm) + 2 * number_of_seams;
}
/// Returns the number of edges in the seam mesh.
/// returns the number of edges in the seam mesh.
halfedges_size_type num_edges() const
{
return CGAL::num_edges(tm) + number_of_seams;
}
/// Returns the number of faces in the seam mesh.
/// returns the number of faces in the seam mesh.
faces_size_type num_faces() const
{
return CGAL::num_faces(tm);
@ -719,7 +719,7 @@ public:
/// \name Degree Functions
/// @{
/// Returns the number of incident halfedges of vertex `v`.
/// returns the number of incident halfedges of vertex `v`.
degree_size_type degree(vertex_descriptor v) const
{
degree_size_type count(0);
@ -743,13 +743,13 @@ public:
#ifndef DOXYGEN_RUNNING
///@{
/// Returns the edge that contains halfedge `h` as one of its two halfedges.
/// returns the edge that contains halfedge `h` as one of its two halfedges.
edge_descriptor edge(halfedge_descriptor h) const
{
return edge_descriptor(h,this);
}
/// Returns the halfedge corresponding to the edge `e`.
/// returns the halfedge corresponding to the edge `e`.
halfedge_descriptor halfedge(edge_descriptor e) const
{
return e.hd;
@ -758,7 +758,7 @@ public:
///@{
/// Returns an incoming halfedge of vertex `v`.
/// returns an incoming halfedge of vertex `v`.
/// If `v` is a seam vertex, this will be the halfedge whose target is `v` and
/// whose opposite is a virtual border halfedge.
/// Otherwise, the rules of the underlying mesh are followed.
@ -769,7 +769,7 @@ public:
return halfedge_descriptor(h, false /*not on seam*/);
}
/// Finds a halfedge between two vertices. Returns a default constructed
/// finds a halfedge between two vertices. Returns a default constructed
/// `halfedge_descriptor`, if `source` and `target` are not connected.
std::pair<halfedge_descriptor, bool> halfedge(vertex_descriptor u,
vertex_descriptor v) const
@ -800,7 +800,7 @@ public:
return std::make_pair(halfedge_descriptor(), false/*invalid*/);
}
/// Finds an edge between two vertices. Returns a default constructed
/// finds an edge between two vertices. Returns a default constructed
/// `edge`, if `source` and `target` are not connected.
std::pair<edge_descriptor, bool> edge(vertex_descriptor u, vertex_descriptor v) const
{
@ -815,7 +815,7 @@ public:
return halfedge_descriptor(hd, false/*not on seam*/);
}
/// Returns the face incident to halfedge `h`.
/// returns the face incident to halfedge `h`.
face_descriptor face(halfedge_descriptor h) const
{
if(h.seam)
@ -825,7 +825,7 @@ public:
}
public:
/// Returns the next halfedge within the incident face.
/// returns the next halfedge within the incident face.
halfedge_descriptor next(const halfedge_descriptor& hd) const
{
if((!hd.seam) && (!is_border(hd.tmhd, tm)))
@ -840,7 +840,7 @@ public:
!is_border(CGAL::opposite(*hatc, tm), tm));
}
/// Returns the previous halfedge within the incident face.
/// returns the previous halfedge within the incident face.
halfedge_descriptor prev(const halfedge_descriptor& hd) const
{
if((!hd.seam) && (!is_border(hd.tmhd, tm)))
@ -855,7 +855,7 @@ public:
!is_border(CGAL::opposite(*hatc, tm), tm));
}
/// Returns the opposite halfedge of `hd`.
/// returns the opposite halfedge of `hd`.
halfedge_descriptor opposite(const halfedge_descriptor& hd) const
{
if(!hd.seam)
@ -864,7 +864,7 @@ public:
return halfedge_descriptor(CGAL::opposite(hd.tmhd, tm), false /*not on seam*/);
}
/// Returns the vertex the halfedge `h` emanates from.
/// returns the vertex the halfedge `h` emanates from.
vertex_descriptor target(halfedge_descriptor hd) const
{
TM_halfedge_descriptor tmhd(hd);
@ -884,7 +884,7 @@ public:
return vertex_descriptor(halfedge_descriptor(tmhd));
}
/// Returns the vertex the halfedge `h` emanates from.
/// returns the vertex the halfedge `h` emanates from.
vertex_descriptor source(const halfedge_descriptor& hd) const
{
return target(opposite(hd));
@ -922,7 +922,7 @@ public:
/// \name Seam selection
/// @{
/// Mark the edge of the underlying mesh that has extremities the vertices
/// marks the edge of the underlying mesh that has extremities the vertices
/// `tm_vd_s` and `tm_vd_s` as a seam edge.
///
/// \return whether the edge was successfully marked or not.
@ -963,7 +963,7 @@ public:
return true;
}
/// Create new seams.
/// creates new seams.
///
/// The edges to be marked as seams are described by the range [first, last) of
/// vertices of the underlying mesh. Each edge to be marked is described
@ -998,7 +998,7 @@ public:
return tmhd;
}
/// Create new seams.
/// creates new seams.
///
/// A seam edge is described by a pair of integers. The integer index
/// of a vertex of the underlying mesh is given by its position
@ -1024,7 +1024,7 @@ public:
return add_seams(seam_vertices.begin(), seam_vertices.end());
}
/// Create new seams.
/// creates new seams.
///
/// A seam edge is described by a pair of integers. The integer
/// index of a vertex of the underlying mesh is defined as its position when
@ -1041,7 +1041,7 @@ public:
return add_seams(in, tm_vds);
}
/// Create new seams.
/// creates new seams.
///
/// A seam edge is described by a pair of integers. The integer index
/// of a vertex of the underlying mesh is given by its position
@ -1085,7 +1085,7 @@ public:
return add_seams(in, tm_vds);
}
/// Create new seams.
/// creates new seams.
///
/// A seam edge is described by a pair of integers. The integer
/// index of a vertex of the underlying mesh is defined as its position when
@ -1104,7 +1104,7 @@ public:
/// @}
/// Constructs a seam mesh for a triangle mesh and an edge and vertex property map
/// constructs a seam mesh for a triangle mesh and an edge and vertex property map
///
/// \param tm the underlying mesh
/// \param sem the edge property map with value `true` for seam edges

34
BGL/include/CGAL/boost/graph/alpha_expansion_graphcut.h
View File

@ -505,27 +505,33 @@ class Alpha_expansion_MaxFlow_impl;
vd)[label_idx]` returns the cost of vertex `vd` to belong to the
label `label_idx`.
\param np optional sequence of named parameters among the ones listed below
\param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_index_map}
a property map providing the index of each vertex
\cgalParamEnd
\cgalParamBegin{implementation_tag}
tag used to select
which implementation of the alpha expansion should be
used. Available implementation tags are:
- `CGAL::Alpha_expansion_boost_adjacency_list` (default)
\cgalParamNBegin{vertex_index_map}
\cgalParamDescription{a property map associating to each vertex of `input_graph` a unique index between `0` and `num_vertices(input_graph) - 1`}
\cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<InputGraph>::%vertex_descriptor`
as key type and `std::size_t` as value type}
\cgalParamDefault{an automatically indexed internal map}
\cgalParamExtra{If this parameter is not passed, internal machinery will create and initialize
a face index property map, either using the internal property map if it exists
or using an external map. The latter might result in - slightly - worsened performance
in case of non-constant complexity for index access.}
\cgalParamNEnd
\cgalParamNBegin{implementation_tag}
\cgalParamDescription{a tag used to select which implementation of the alpha expansion should be used.
Available implementation tags are:
- `CGAL::Alpha_expansion_boost_adjacency_list`
- `CGAL::Alpha_expansion_boost_compressed_sparse_row_tag`
- `CGAL::Alpha_expansion_MaxFlow_tag`
\cgalParamEnd
- `CGAL::Alpha_expansion_MaxFlow_tag`}
\cgalParamDefault{`CGAL::Alpha_expansion_boost_adjacency_list`}
\cgalParamNEnd
\cgalNamedParamsEnd
\note The `MaxFlow` implementation is provided by the \ref PkgSurfaceMeshSegmentationRef
under GPL license. The header
`<CGAL/boost/graph/Alpha_expansion_MaxFlow_tag.h>`
under GPL license. The header `<CGAL/boost/graph/Alpha_expansion_MaxFlow_tag.h>`
must be included if users want to use this implementation.
*/
template <typename InputGraph,
typename EdgeCostMap,

111
BGL/include/CGAL/boost/graph/copy_face_graph.h
View File

@ -254,58 +254,97 @@ inline Emptyset_iterator make_functor(const internal_np::Param_not_found&)
and `boost::graph_traits<SourceMesh>::%face_descriptor` must be
models of `Hashable`.
\tparam TargetMesh a model of `FaceListGraph`
\tparam NamedParameters1 a sequence of \ref pmp_namedparameters "Named Parameters"
\tparam NamedParameters2 a sequence of \ref pmp_namedparameters "Named Parameters"
\tparam NamedParameters1 a sequence of \ref bgl_namedparameters "Named Parameters"
\tparam NamedParameters2 a sequence of \ref bgl_namedparameters "Named Parameters"
The types `sm_vertex_descriptor` and `sm_face_descriptor` must be models of the concept `Hashable`.
\param sm the source mesh
\param tm the target mesh
\param np1 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\param np1 an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map}
the property map with the points associated to the vertices of `sm` .
If this parameter is omitted, an internal property map for
`CGAL::vertex_point_t` should be available in `SourceMesh`
\cgalParamEnd
\cgalParamBegin{vertex_to_vertex_output_iterator} an `OutputIterator` containing the
pairs source-vertex, target-vertex. If this parameter is given, then
`vertex_to_vertex_map` cannot be used.
\cgalParamEnd
\cgalParamBegin{halfedge_to_halfedge_output_iterator} an `OutputIterator` containing the
pairs source-halfedge, target-halfedge. If this parameter is given, then
`halfedge_to_halfedge_map` cannot be used.
\cgalParamEnd
\cgalParamBegin{face_to_face_output_iterator} an `OutputIterator` containing the
pairs source-face, target-face. If this parameter is given, then
`face_to_face_map` cannot be used.
\cgalParamEnd
\cgalParamBegin{vertex_to_vertex_map} a `ReadWritePropertyMap` containing the
pairs source-vertex, target-vertex.
\cgalParamEnd
\cgalParamBegin{halfedge_to_halfedge_map} a `ReadWritePropertyMap` containing the
pairs source-halfedge, target-halfedge.
\cgalParamEnd
\cgalParamBegin{face_to_face_map} a `ReadWritePropertyMap` containing the
pairs source-face, target-face.
\cgalParamEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `sm`}
\cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<SourceMesh>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, sm)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `SourceMesh`.}
\cgalParamNEnd
\cgalParamNBegin{vertex_to_vertex_output_iterator}
\cgalParamDescription{an `OutputIterator` containing the pairs source-vertex, target-vertex.}
\cgalParamType{a class model of `OutputIterator` accepting
`std::pair<`boost::graph_traits<SourceMesh>::%vertex_descriptor, `boost::graph_traits<TargetMesh>::%vertex_descriptor>`}
\cgalParamDefault{`Emptyset_iterator`}
\cgalParamExtra{If this parameter is given, then `vertex_to_vertex_map` cannot be used.}
\cgalParamNEnd
\cgalParamNBegin{halfedge_to_halfedge_output_iterator}
\cgalParamDescription{an `OutputIterator` containing the pairs source-halfedge, target-halfedge.}
\cgalParamType{a class model of `OutputIterator` accepting
`std::pair<`boost::graph_traits<SourceMesh>::%halfedge_descriptor, `boost::graph_traits<TargetMesh>::%halfedge_descriptor>`}
\cgalParamDefault{`Emptyset_iterator`}
\cgalParamExtra{If this parameter is given, then `halfedge_to_halfedge_map` cannot be used.}
\cgalParamNEnd
\cgalParamNBegin{face_to_face_output_iterator}
\cgalParamDescription{an `OutputIterator` containing the pairs source-face, target-face.}
\cgalParamType{a class model of `OutputIterator` accepting
`std::pair<`boost::graph_traits<SourceMesh>::%face_descriptor, `boost::graph_traits<TargetMesh>::%face_descriptor>`}
\cgalParamDefault{`Emptyset_iterator`}
\cgalParamExtra{If this parameter is given, then `face_to_face_map` cannot be used.}
\cgalParamNEnd
\cgalParamNBegin{vertex_to_vertex_map}
\cgalParamDescription{a property map storing for each vertex of a source mesh the corresponding vertex of another mesh}
\cgalParamType{a class model of `ReadWritePropertyMap` with
`boost::graph_traits<SourceMesh>::%vertex_descriptor` as key type and
`boost::graph_traits<TargetMesh>::%vertex_descriptor` as value type.}
\cgalParamDefault{unused}
\cgalParamExtra{A typical use case is mapping the vertices from a source mesh
to its copy's after a `copy_face_graph()` operation.}
\cgalParamNEnd
\cgalParamNBegin{halfedge_to_halfedge_map}
\cgalParamDescription{a property map storing for each halfedge of a source mesh the corresponding halfedge of another mesh}
\cgalParamType{a class model of `ReadWritePropertyMap` with
`boost::graph_traits<SourceMesh>::%halfedge_descriptor` as key type and
`boost::graph_traits<TargetMesh>::%halfedge_descriptor` as value type}
\cgalParamDefault{unused}
\cgalParamExtra{A typical use case is mapping the halfedges from a source mesh to its copy's
after a `copy_face_graph()`operation.}
\cgalParamNEnd
\cgalParamNBegin{face_to_face_map}
\cgalParamDescription{a property map storing for each face of a source mesh the corresponding face of another mesh}
\cgalParamType{a class model of `ReadWritePropertyMap` with
`boost::graph_traits<SourceMesh>::%face_descriptor` as key type and
`boost::graph_traits<TargetMesh>::%face_descriptor` as value type}
\cgalParamDefault{unused}
\cgalParamExtra{A typical use case is mapping the faces from a source mesh to its copy's
after a `copy_face_graph()` operation}
\cgalParamNEnd
\cgalNamedParamsEnd
\param np2 optional sequence of \ref pmp_namedparameters "Named Parameters" among the ones listed below
\param np2 an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{vertex_point_map}
the property map with the points associated to the vertices of `tm`.
If this parameter is omitted, an internal property map for
`CGAL::vertex_point_t` should be available in `TargetMesh`
\cgalParamEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `tm`}
\cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TargetMesh>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `TargetMesh`.}
\cgalParamNEnd
\cgalNamedParamsEnd
The points from `sm` to `tm` are converted using
`CGAL::Cartesian_converter<SourceKernel, TargetKernel>`.
`SourceKernel` and `TargetKernel` are deduced using `CGAL::Kernel_traits`
from the value types of the vertex_point_maps.
from the value types of the vertex point maps.
Other properties are not copied.
*/

95
BGL/include/CGAL/boost/graph/io.h
View File

@ -27,15 +27,26 @@
#include <CGAL/IO/write_vtk.h>
namespace CGAL {
/*!
\ingroup PkgBGLIOFct
writes the graph `g` in the wrl format (VRML 2.0).
\param os the output stream
\param g the graph to be written
\param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `g`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` should be available in `FaceGraph`\cgalParamEnd
* \cgalNamedParamsEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `g`}
\cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<FaceGraph>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, g)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `FaceGraph`.}
\cgalParamNEnd
\cgalNamedParamsEnd
*/
template <typename FaceGraph, typename NamedParameters>
bool write_wrl(std::ostream& os,
@ -115,16 +126,25 @@ bool write_wrl(std::ostream& os,
/*!
\ingroup PkgBGLIOFct
writes the graph `g` in the OFF format.
\param os the output stream
\param g the graph to be written
\param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `g`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` should be available in `FaceGraph`\cgalParamEnd
* \cgalNamedParamsEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `g`}
\cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<FaceGraph>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, g)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `FaceGraph`.}
\cgalParamNEnd
\cgalNamedParamsEnd
\sa Overloads of this function for specific models of the concept `FaceGraph`.
*/
template <typename FaceGraph, typename NamedParameters>
bool write_off(std::ostream& os,
@ -237,17 +257,28 @@ inline std::string next_non_comment(std::istream& is)
/*!
\ingroup PkgBGLIOFct
reads the graph `g` from data in the OFF format. Ignores comment lines which start with a hash, and lines with whitespace.
\param is the input stream
\param g the graph to be read
\param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `g`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` should be available in `FaceGraph`\cgalParamEnd
* \cgalNamedParamsEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `g`}
\cgalParamType{a class model of `WritablePropertyMap` with `boost::graph_traits<FaceGraph>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, g)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `FaceGraph`.}
\cgalParamNEnd
\cgalNamedParamsEnd
\sa Overloads of this function for specific models of the concept `FaceGraph`.
\pre The data must represent a 2-manifold
\attention The graph `g` is not cleared, and the data from the stream are added.
\attention The graph `g` is not cleared, and the data from the stream are added.
*/
template <typename FaceGraph, typename NamedParameters>
bool read_off(std::istream& is,
@ -614,24 +645,34 @@ write_polys_points(std::ostream& os,
* \brief writes a triangulated surface mesh in the `PolyData` XML format.
*
* \tparam TriangleMesh a model of `FaceListGraph` with only triangle faces.
* \tparam NamedParameters a sequence of \ref pmp_namedparameters "Named Parameters"
* \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
*
* \param os the stream used for writing.
* \param mesh the triangle mesh to be written.
* \param np optional sequence of \ref pmp_namedparameters "Named Parameters" among the
* ones listed below
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{use_binary_mode} a Boolean indicating if the
* data should be written in binary (`true`, the default) or in ASCII (`false`).
* \cgalParamEnd
* \cgalParamBegin{vertex_point_map} the property map with the points associated to
* the vertices of `mesh`. If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `TriangleMesh`.
* \cgalParamEnd
* \cgalParamBegin{vertex_index_map} the property map with the indices associated to
* the vertices of `mesh`.
* \cgalParamEnd
* \cgalParamNBegin{use_binary_mode}
* \cgalParamDescription{Boolean indicating if the data should be written in binary (`true`) or in ASCII (`false`)}
* \cgalParamType{Boolean}
* \cgalParamDefault{`true`}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `mesh`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, mesh)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `TriangleMesh`.}
* \cgalParamNEnd
*
* \cgalParamNBegin{vertex_index_map}
* \cgalParamDescription{a property map associating to each vertex of `mesh` a unique index between `0` and `num_vertices(mesh) - 1`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
* as key type and `std::size_t` as value type}
* \cgalParamDefault{an automatically indexed internal map}
* \cgalParamNEnd
* \cgalNamedParamsEnd
*/
template<class TriangleMesh,

1
BGL/include/CGAL/boost/graph/parameters_interface.h
View File

@ -172,6 +172,7 @@ CGAL_add_named_parameter(remesh_boundaries_t, remesh_boundaries, remesh_boundari
CGAL_add_named_parameter(cell_selector_t, cell_selector, cell_selector)
CGAL_add_named_parameter(facet_is_constrained_t, facet_is_constrained, facet_is_constrained_map)
CGAL_add_named_parameter(remeshing_visitor_t, remeshing_visitor, remeshing_visitor)
CGAL_add_named_parameter(smooth_constrained_edges_t, smooth_constrained_edges, smooth_constrained_edges)
// output parameters
CGAL_add_named_parameter(face_proxy_map_t, face_proxy_map, face_proxy_map)

54
BGL/include/CGAL/boost/graph/selection.h
View File

@ -286,7 +286,7 @@ struct Regularization_graph
/*!
\ingroup PkgBGLSelectionFct
Augments a selection with faces of `fg` that are adjacent
augments a selection with faces of `fg` that are adjacent
to a face in `selection`. This process is applied `k` times considering
all faces added in the previous steps.
Two faces are said to be adjacent if they share a vertex or an edge.
@ -356,7 +356,7 @@ expand_face_selection(
/*!
\ingroup PkgBGLSelectionFct
Diminishes a selection of faces from faces adjacent to a non-selected face.
diminishes a selection of faces from faces adjacent to a non-selected face.
This process is applied `k` times considering all faces removed in the previous steps.
Two faces are said to be adjacent if they share a vertex or an edge.
Each face removed from the selection is added exactly once in `out`.
@ -464,20 +464,38 @@ reduce_face_selection(
unselects everything so that the length of the border of the
selection is 0)
\param np optional sequence of named parameters among the ones listed below
\param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{face_index_map}
the property map with the indices associated to the faces of `mesh`
\cgalParamEnd
\cgalParamBegin{vertex_point_map}
the property map with the points associated to the vertices of `mesh`
\cgalParamEnd
\cgalParamBegin{prevent_unselection}
if `true` only new faces can be selected, if `false` (default) some
faces can be unselected
\cgalParamEnd
\cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
\cgalParamNBegin{vertex_point_map}
\cgalParamDescription{a property map associating points to the vertices of `tm`}
\cgalParamType{a class model of `ReadWritePropertyMap` with `boost::graph_traits<TriangleMesh>::%vertex_descriptor`
as key type and `%Point_3` as value type}
\cgalParamDefault{`boost::get(CGAL::vertex_point, tm)`}
\cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
must be available in `TriangleMesh`.}
\cgalParamNEnd
\cgalParamNBegin{face_index_map}
\cgalParamDescription{a property map associating to each face of `tm` a unique index between `0` and `num_faces(tm) - 1`}
\cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<TriangleMesh>::%face_descriptor`
as key type and `std::size_t` as value type}
\cgalParamDefault{an automatically indexed internal map}
\cgalParamNEnd
\cgalParamNBegin{prevent_unselection}
\cgalParamDescription{Boolean used to indicate if selection can be only extended or if it can also be shrinked.}
\cgalParamType{`bool`}
\cgalParamDefault{`false`}
\cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
\cgalParamNEnd
\cgalParamNBegin{geom_traits}
\cgalParamDescription{an instance of a geometric traits class}
\cgalParamType{a class model of `Kernel`}
\cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
\cgalParamExtra{The geometric traits class must be compatible with the vertex point type.}
\cgalParamNEnd
\cgalNamedParamsEnd
*/
template <typename TriangleMesh, typename IsSelectedMap, typename NamedParameters>
@ -731,7 +749,7 @@ select_incident_faces(
/*!
\ingroup PkgBGLSelectionFct
Augments a selection with edges of `fg` that are adjacent
augments a selection with edges of `fg` that are adjacent
to an edge in `selection`. This process is applied `k` times considering
all edges added in the previous steps.
Two edges are said to be adjacent if they are incident to the same face or vertex.
@ -798,7 +816,7 @@ expand_edge_selection(
/*!
\ingroup PkgBGLSelectionFct
Diminishes a selection of edges from edges adjacent to a non-selected edge.
diminishes a selection of edges from edges adjacent to a non-selected edge.
This process is applied `k` times considering all edges removed in the previous steps.
Two edges are said to be adjacent if they are incident to the same face or vertex.
Each edge removed from the selection is added exactly once in `out`.
@ -884,7 +902,7 @@ reduce_edge_selection(
/*!
\ingroup PkgBGLSelectionFct
Augments a selection with vertices of `fg` that are adjacent
augments a selection with vertices of `fg` that are adjacent
to a vertex in `selection`. This process is applied `k` times considering
all vertices added in the previous steps.
Two vertices are said to be adjacent if they are part of the same face.
@ -939,7 +957,7 @@ expand_vertex_selection(
/*!
\ingroup PkgBGLSelectionFct
Diminishes a selection of vertices from vertices adjacent to a non-selected vertex.
diminishes a selection of vertices from vertices adjacent to a non-selected vertex.
This process is applied `k` times considering all vertices removed in the previous steps.
Two vertices are said to be adjacent if they are part of the same face.
Each vertex removed from the selection is added exactly once in `out`.

2
BGL/include/CGAL/boost/graph/split_graph_into_polylines.h
View File

@ -131,7 +131,7 @@ public:
}
}; // end class Less_on_G_copy_vertex_descriptors
// Splits a graph at vertices with degree higher than two and at vertices where `is_terminal` returns `true`
// splits a graph at vertices with degree higher than two and at vertices where `is_terminal` returns `true`
// The vertices are duplicated, and new incident edges created.
// `OrigGraph` must be undirected
template <typename Graph,

2
CGAL_Core/include/CGAL/CORE/BigFloat_impl.h
View File

@ -78,12 +78,14 @@ BigInt FiveTo(unsigned long exp) {
// ZERO
CGAL_INLINE_FUNCTION
const BigFloat& BigFloat::getZero() {
init_CORE();
CGAL_STATIC_THREAD_LOCAL_VARIABLE(BigFloat, Zero,0);
return Zero;
}
// ONE
CGAL_INLINE_FUNCTION
const BigFloat& BigFloat::getOne() {
init_CORE();
CGAL_STATIC_THREAD_LOCAL_VARIABLE(BigFloat, One,1);
return One;
}

2
CGAL_Core/include/CGAL/CORE/Expr_impl.h
View File

@ -61,11 +61,13 @@ const char* Sub::name = "-";
********************************************************/
CGAL_INLINE_FUNCTION
const Expr& Expr::getZero() {
init_CORE();
CGAL_STATIC_THREAD_LOCAL_VARIABLE(Expr, Zero,0);
return Zero;
}
CGAL_INLINE_FUNCTION
const Expr& Expr::getOne() {
init_CORE();
CGAL_STATIC_THREAD_LOCAL_VARIABLE(Expr, One,1);
return One;
}

23
CGAL_Core/include/CGAL/CORE/MemoryPool.h
View File

@ -26,14 +26,6 @@
#include <CGAL/config.h>
#include <CGAL/tss.h>
#include <boost/config.hpp>
#if defined(CGAL_HAS_THREADS) && defined(BOOST_GCC) && BOOST_GCC < 90100
// Force the use of Boost.Thread with g++ and C++11, because of the PR66944
// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66944
// See also CGAL PR #1888
// https://github.com/CGAL/cgal/pull/1888#issuecomment-278284232
# include <boost/thread/tss.hpp>
#endif
#include <new> // for placement new
#include <cassert>
@ -85,10 +77,7 @@ public:
// Access the corresponding static global allocator.
static MemoryPool<T,nObjects>& global_allocator() {
#if defined(CGAL_HAS_THREADS) && defined(BOOST_GCC) && BOOST_GCC < 90100
if(memPool_ptr.get() == nullptr) {memPool_ptr.reset(new Self());}
Self& memPool = * memPool_ptr.get();
#elif defined(CGAL_HAS_THREADS) // use the C++11 implementation
#if defined(CGAL_HAS_THREADS) // use the C++11 implementation
static thread_local Self memPool;
#else // not CGAL_HAS_THREADS
static Self memPool;
@ -99,18 +88,8 @@ public:
private:
Thunk* head; // next available block in the pool
std::vector<void*> blocks;
#if defined(CGAL_HAS_THREADS) && defined(BOOST_GCC) && BOOST_GCC < 90100
static boost::thread_specific_ptr<Self> memPool_ptr;
#endif // not CGAL_HAS_THREADS
};
#if defined(CGAL_HAS_THREADS) && defined(BOOST_GCC) && BOOST_GCC < 90100
template <class T, int nObjects >
boost::thread_specific_ptr<MemoryPool<T, nObjects> >
MemoryPool<T, nObjects>::memPool_ptr;
#endif
template< class T, int nObjects >
void* MemoryPool< T, nObjects >::allocate(std::size_t) {
if ( head == 0 ) { // if no more memory in the pool

8
CGAL_Core/include/CGAL/CORE/Real.h
View File

@ -27,7 +27,9 @@
***************************************************************************/
#ifndef _CORE_REAL_H_
#define _CORE_REAL_H_
#include "RealRep.h"
#include <CGAL/use.h>
namespace CORE {
// class Real
@ -483,6 +485,12 @@ inline Real RealLong::operator-() const {
return ker < -LONG_MAX ? -BigInt(ker) : -ker;
}
inline void init_CORE() {
using RealRep = CORE::RealDouble;
CGAL_STATIC_THREAD_LOCAL_VARIABLE(MemoryPool<RealRep>*, pool_real_rep, &MemoryPool<RealRep>::global_allocator());
CGAL_USE(pool_real_rep);
}
} //namespace CORE
#ifdef CGAL_HEADER_ONLY

1
CGAL_Core/include/CGAL/CORE/Real_impl.h
View File

@ -44,6 +44,7 @@ namespace CORE {
CGAL_INLINE_FUNCTION
const Real& Real::getZero() {
init_CORE();
CGAL_STATIC_THREAD_LOCAL_VARIABLE(Real, Zero, 0);
return Zero;
}

2
CGAL_Core/include/CGAL/CORE/poly/Poly.h
View File

@ -252,6 +252,7 @@ public:
template < class NT >
CORE_INLINE
const Polynomial<NT> & Polynomial<NT>::polyZero() {
init_CORE();
CGAL_STATIC_THREAD_LOCAL_VARIABLE_0(Polynomial<NT>, zeroP);
return zeroP;
}
@ -259,6 +260,7 @@ const Polynomial<NT> & Polynomial<NT>::polyZero() {
template < class NT >
CORE_INLINE
const Polynomial<NT> & Polynomial<NT>::polyUnity() {
init_CORE();
static const NT c[] = {1};
CGAL_STATIC_THREAD_LOCAL_VARIABLE_2(Polynomial<NT>, unityP, 0, c);
return unityP;

7
CGAL_Core/include/CGAL/CORE/poly/Poly.tcc
View File

@ -670,19 +670,20 @@ Polynomial<NT> Polynomial<NT>::pseudoRemainder (
contract(); // Let A = (*this). Contract A.
Polynomial<NT> tmpB(B);
tmpB.contract(); // local copy of B
int bTrueDegree = tmpB.degree;
C = NT(1); // Initialized to C=1.
if (B.degree == -1) {
if (bTrueDegree == -1) {
core_error("ERROR in Polynomial<NT>::pseudoRemainder :\n -- divide by zero polynomial", __FILE__, __LINE__, false);
return Polynomial(0); // Unit Polynomial (arbitrary!)
}
if (B.degree > degree) {
if (bTrueDegree > degree) {
return Polynomial(); // Zero Polynomial
// CHECK: 1*THIS = 0*B + THAT, deg(THAT) < deg(B)
}
Polynomial<NT> Quo; // accumulate the return polynomial, Quo
Polynomial<NT> tmpQuo;
while (degree >= B.degree) { // INVARIANT: C*A = B*Quo + (*this)
while (degree >= bTrueDegree) { // INVARIANT: C*A = B*Quo + (*this)
tmpQuo = reduceStep(tmpB); // Let (*this) be (*oldthis), which
// is transformed into (*newthis). Then,
// c*(*oldthis) = B*m + (*newthis)

16
Convex_hull_3/doc/Convex_hull_3/CGAL/convex_hull_3.h
View File

@ -44,18 +44,22 @@ void convex_hull_3(InputIterator first, InputIterator last, PolygonMesh& pm, con
* if the convex hull is a point or a segment, endpoints will be added in `pm` as isolated vertices.
*
* \tparam VertexListGraph a model of `VertexListGraph`.
* \tparam PolygonMesh must be a model of `MutableFaceGraph`.
* \tparam PolygonMesh must be a model of `MutableFaceGraph`. an internal property map for `CGAL::vertex_point_t` must be available.
* \tparam NamedParameters a sequence of named parameters
*
* \param g the graph
* \param pm the `PolygonMesh` that will contain the convex hull
* \param np optional sequence of named parameters among the ones listed below
* \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
*
* \cgalNamedParamsBegin
* \cgalParamBegin{vertex_point_map} the property map with the points associated to the vertices of `g`.
* If this parameter is omitted, an internal property map for
* `CGAL::vertex_point_t` must be available in `VertexListGraph`
* \cgalParamEnd
* \cgalParamNBegin{vertex_point_map}
* \cgalParamDescription{a property map associating points to the vertices of `g`}
* \cgalParamType{a class model of `ReadablePropertyMap` with `boost::graph_traits<VertexListGraph>::%vertex_descriptor`
* as key type and `%Point_3` as value type}
* \cgalParamDefault{`boost::get(CGAL::vertex_point, g)`}
* \cgalParamExtra{If this parameter is omitted, an internal property map for `CGAL::vertex_point_t`
* must be available in `VertexListGraph`.}
* \cgalParamNEnd
* \cgalNamedParamsEnd
* \attention The user must include the header file of the `PolygonMesh` and `VertexListGraph` types.
*/

6
Convex_hull_3/doc/Convex_hull_3/Doxyfile.in
View File

@ -1,9 +1,3 @@
@INCLUDE = ${CGAL_DOC_PACKAGE_DEFAULTS}
PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - 3D Convex Hulls"
\# macros to be used inside the code
ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref BGL_\1 \"\1\"</td><td>"
ALIASES += "cgalParamEnd=</td></tr>"

26
Documentation/doc/Documentation/Developer_manual/Chapter_portability.txt
View File

@ -101,70 +101,70 @@ the following table.
<TD ALIGN=LEFT NOWRAP>
GNU 3.2.1
<TD ALIGN=LEFT NOWRAP>
<TT>__GNUC__</TT>
`__GNUC__`
<TD ALIGN=LEFT NOWRAP>
3
<TR>
<TD ALIGN=LEFT NOWRAP>
GNU 3.2.1
<TD ALIGN=LEFT NOWRAP>
<TT>__GNUC_MINOR__</TT>
`__GNUC_MINOR__`
<TD ALIGN=LEFT NOWRAP>
2
<TR>
<TD ALIGN=LEFT NOWRAP>
GNU 3.2.1
<TD ALIGN=LEFT NOWRAP>
<TT>__GNUC_PATCHLEVEL__</TT>
`__GNUC_PATCHLEVEL__`
<TD ALIGN=LEFT NOWRAP>
1
<TR>
<TD ALIGN=LEFT NOWRAP>
Microsoft VC7.1
<TD ALIGN=LEFT NOWRAP>
<TT>_MSC_VER</TT>
`_MSC_VER`
<TD ALIGN=LEFT NOWRAP>
1310
<TR>
<TD ALIGN=LEFT NOWRAP>
Microsoft VC8.0
<TD ALIGN=LEFT NOWRAP>
<TT>_MSC_VER</TT>
`_MSC_VER`
<TD ALIGN=LEFT NOWRAP>
1400
<TR>
<TD ALIGN=LEFT NOWRAP>
Intel 11.1
<TD ALIGN=LEFT NOWRAP>
<TT>__INTEL_COMPILER</TT>
`__INTEL_COMPILER`
<TD ALIGN=LEFT NOWRAP>
1110
<TR>
<TD ALIGN=LEFT NOWRAP>
Clang 2.9
<TD ALIGN=LEFT NOWRAP>
<TT>__clang_major__</TT>
`__clang_major__`
<TD ALIGN=LEFT NOWRAP>
2
<TR>
<TD ALIGN=LEFT NOWRAP>
Clang 2.9
<TD ALIGN=LEFT NOWRAP>
<TT>__clang_minor__</TT>
`__clang_minor__`
<TD ALIGN=LEFT NOWRAP>
9
<TR>
<TD ALIGN=LEFT NOWRAP>
SUN 5.3
<TD ALIGN=LEFT NOWRAP>
<TT>__SUNPRO_CC</TT>
`__SUNPRO_CC`
<TD ALIGN=LEFT NOWRAP>
0x530
<TR>
<TD ALIGN=LEFT NOWRAP>
SUN 5.10
<TD ALIGN=LEFT NOWRAP>
<TT>__SUNPRO_CC</TT>
`__SUNPRO_CC`
<TD ALIGN=LEFT NOWRAP>
0x5100
</TABLE>
@ -178,17 +178,17 @@ There are also flags to identify the architecture.
<TD ALIGN=LEFT NOWRAP>
SGI
<TD ALIGN=LEFT NOWRAP>
<TT>__sgi</TT>
`__sgi`
<TR>
<TD ALIGN=LEFT NOWRAP>
SUN
<TD ALIGN=LEFT NOWRAP>
<TT>__sun</TT>
`__sun`
<TR>
<TD ALIGN=LEFT NOWRAP>
Linux
<TD ALIGN=LEFT NOWRAP>
<TT>__linux</TT>
`__linux`
</TABLE>
</TABLE>

6
Documentation/doc/Documentation/Third_party.txt
View File

@ -56,7 +56,7 @@ or <A HREF="https://msdn.microsoft.com/en-us/library/1fe2x6kt(v=vs.140).aspx">`h
The \stl comes with the compiler, and as such no installation is required.
\subsection thirdpartyBoost Boost
<b>Version 1.62 or later</b>
<b>Version 1.66 or later</b>
The \sc{Boost} libraries are a set of portable C++ source libraries.
Most of \sc{Boost} libraries are header-only, but a few of them need to be compiled or
@ -64,10 +64,6 @@ installed as binaries.
\cgal only requires the headers of the \sc{Boost} libraries, but some demos and examples
depend on the binary library `Boost.Program_options`.
As an exception and because of a bug in the \gcc compiler about the \cpp 11
keyword `thread_local`, the `CGAL_Core` library always requires
the binary library `Boost.Thread` if the \gcc compiler version 9.0 or
earlier is used.
In case the \sc{Boost} libraries are not installed on your system already, you
can obtain them from <A HREF="https://www.boost.org">`https://www.boost.org/`</A>.

11
Documentation/doc/resources/1.8.13/BaseDoxyfile.in
View File

@ -299,7 +299,16 @@ ALIASES = "sc{1}=<span style=\"font-variant: small-caps;\">\1</sp
"cgalCRPSection{1}=<h2>\1</h2>" \
"cgalCRPSubsection{1}=<h3>\1</h3>" \
"cgalCite{1}=<!-- -->\cite \1" \
"cgalPackageSection{2}=\htmlonly[block] <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 \n \htmlonly[block] </div>\endhtmlonly"
"cgalPackageSection{2}=\htmlonly[block] <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 \n \htmlonly[block] </div>\endhtmlonly" \
"cgalNamedParamsBegin=<dl class=\"params\"><dt>Optional Named Parameters</dt><dd> <table class=\"params\">" \
"cgalNamedParamsBegin{1}=<dl class=\"params\"><dt>\1</dt><dd> <table class=\"params\">" \
"cgalNamedParamsEnd=</table> </dd> </dl>" \
"cgalParamNBegin{1}=<tr><td class> \htmlonly[block] <button class=\"collapsible\">\endhtmlonly <b>\1</b> \htmlonly[block]</button> <div class=\"content\">\endhtmlonly<ul>" \
"cgalParamDescription{1}=<li>\1</li>" \
"cgalParamType{1}=<li><b>Type: </b>\1</li>" \
"cgalParamDefault{1}=<li><b>%Default: </b>\1</li>" \
"cgalParamExtra{1}=<li><b>Extra: </b>\1</li>" \
"cgalParamNEnd=</ul> \htmlonly[block] </div> \endhtmlonly </td><td></td></tr>"
# This tag can be used to specify a number of word-keyword mappings (TCL only).
# A mapping has the form "name=value". For example adding "class=itcl::class"

38
Documentation/doc/resources/1.8.13/cgal_stylesheet.css
View File

@ -345,3 +345,41 @@ div.summary
{
width: auto;
}
.collapsible {
background-color: white;
color: #602020;
cursor: pointer;
padding: 3px;
width: 100%;
border: none;
text-align: left;
outline: none;
font: 14px Roboto,sans-serif;
}
.active, .collapsible:hover {
background-color: white;
}
.collapsible:after {
content: '\25B6';
color: #7A93C5;
font-weight: bold;
float: left;
margin-left: -20px;
margin-right: 5px;
}
.active:after {
content: "\25BC";
}
.content {
padding: 0 18px;
color: black;
max-height: 0;
overflow: hidden;
transition: max-height 0.2s ease-out;
background-color: white;
}

16
Documentation/doc/resources/1.8.13/hacks.js
View File

@ -110,3 +110,19 @@ $(document).ready(function() {
}
})();
$(document).ready(function() {
var coll = document.getElementsByClassName("collapsible");
var i;
for (i = 0; i < coll.length; i++) {
coll[i].addEventListener("click", function() {
this.classList.toggle("active");
var content = this.nextElementSibling;
if (content.style.maxHeight){
content.style.maxHeight = null;
} else {
content.style.maxHeight = content.scrollHeight + "px";
}
});
}
});

10
Documentation/doc/resources/1.8.13/menu_version.js
View File

@ -1,15 +1,15 @@
(function() {
'use strict';
var url_re = /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+))\//;
var url_re = /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
var url_local = /.*\/doc_output\//;
var current_version_local = '5.1-beta1'
var current_version_local = '5.0.3'
var all_versions = [
'master',
'latest',
'5.1-beta1',
'5.0.2',
'4.14.3',
'5.1-beta2',
'5.0.3',
'4.14.2',
'4.13.2',
'4.12.2',
'4.11.3',

4
Documentation/doc/resources/1.8.13/stylesheet.css
View File

@ -1245,10 +1245,12 @@ dl.citelist dt {
font-weight:bold;
margin-right:10px;
padding:5px;
text-align:right;
width:52px;
}
dl.citelist dd {
margin:2px 0;
margin:2px 0 2px 72px;
padding:5px 0;
}

11
Documentation/doc/resources/1.8.14/BaseDoxyfile.in
View File

@ -300,7 +300,16 @@ ALIASES = "sc{1}=<span style=\"font-variant: small-caps;\">\1</sp
"cgalCRPSection{1}=<h2>\1</h2>" \
"cgalCRPSubsection{1}=<h3>\1</h3>" \
"cgalCite{1}=<!-- -->\cite \1" \
"cgalPackageSection{2}=\htmlonly[block] <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 ^^ \htmlonly[block] </div>\endhtmlonly"
"cgalPackageSection{2}=\htmlonly[block] <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 ^^ \htmlonly[block] </div>\endhtmlonly" \
"cgalNamedParamsBegin=<dl class=\"params\"><dt>Optional Named Parameters</dt><dd> <table class=\"params\">" \
"cgalNamedParamsBegin{1}=<dl class=\"params\"><dt>\1</dt><dd> <table class=\"params\">" \
"cgalNamedParamsEnd=</table> </dd> </dl>" \
"cgalParamNBegin{1}=<tr><td class> \htmlonly[block] <button class=\"collapsible\">\endhtmlonly <b>\1</b> \htmlonly[block]</button> <div class=\"content\">\endhtmlonly<ul>" \
"cgalParamDescription{1}=<li>\1</li>" \
"cgalParamType{1}=<li><b>Type: </b>\1</li>" \
"cgalParamDefault{1}=<li><b>%Default: </b>\1</li>" \
"cgalParamExtra{1}=<li><b>Extra: </b>\1</li>" \
"cgalParamNEnd=</ul> \htmlonly[block] </div> \endhtmlonly </td><td></td></tr>"
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
# only. Doxygen will then generate output that is more tailored for C. For

38
Documentation/doc/resources/1.8.14/cgal_stylesheet.css
View File

@ -345,3 +345,41 @@ div.summary
{
width: auto;
}
.collapsible {
background-color: white;
color: #602020;
cursor: pointer;
padding: 3px;
width: 100%;
border: none;
text-align: left;
outline: none;
font: 14px Roboto,sans-serif;
}
.active, .collapsible:hover {
background-color: white;
}
.collapsible:after {
content: '\25B6';
color: #7A93C5;
font-weight: bold;
float: left;
margin-left: -20px;
margin-right: 5px;
}
.active:after {
content: "\25BC";
}
.content {
padding: 0 18px;
color: black;
max-height: 0;
overflow: hidden;
transition: max-height 0.2s ease-out;
background-color: white;
}

16
Documentation/doc/resources/1.8.14/hacks.js
View File

@ -110,3 +110,19 @@ $(document).ready(function() {
}
})();
$(document).ready(function() {
var coll = document.getElementsByClassName("collapsible");
var i;
for (i = 0; i < coll.length; i++) {
coll[i].addEventListener("click", function() {
this.classList.toggle("active");
var content = this.nextElementSibling;
if (content.style.maxHeight){
content.style.maxHeight = null;
} else {
content.style.maxHeight = content.scrollHeight + "px";
}
});
}
});

10
Documentation/doc/resources/1.8.14/menu_version.js
View File

@ -1,15 +1,15 @@
(function() {
'use strict';
var url_re = /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+))\//;
var url_re = /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
var url_local = /.*\/doc_output\//;
var current_version_local = '5.1-beta1'
var current_version_local = '5.0.3'
var all_versions = [
'master',
'latest',
'5.1-beta1',
'5.0.2',
'4.14.3',
'5.1-beta2',
'5.0.3',
'4.14.2',
'4.13.2',
'4.12.2',
'4.11.3',

4
Documentation/doc/resources/1.8.14/stylesheet.css
View File

@ -1245,10 +1245,12 @@ dl.citelist dt {
font-weight:bold;
margin-right:10px;
padding:5px;
text-align:right;
width:52px;
}
dl.citelist dd {
margin:2px 0;
margin:2px 0 2px 72px;
padding:5px 0;
}

10
Documentation/doc/resources/1.8.4/BaseDoxyfile.in
View File

@ -305,6 +305,16 @@ ALIASES+= "cgalCite{1}=<!-- -->\cite \1"
ALIASES+= "cgalPackageSection{2}=\htmlonly <div style=\"background-color: #EEEDF2;\">\endhtmlonly \section \1 \2 \n \htmlonly </div>\endhtmlonly"
ALIASES+= "cgalNamedParamsBegin=<dl class=\"params\"><dt>Optional Named Parameters</dt><dd> <table class=\"params\">"
ALIASES+= "cgalNamedParamsBegin{1}=<dl class=\"params\"><dt>\1</dt><dd> <table class=\"params\">"
ALIASES+= "cgalNamedParamsEnd=</table> </dd> </dl>"
ALIASES+= "cgalParamNBegin{1}=<tr><td class> \htmlonly[block] <button class=\"collapsible\">\endhtmlonly <b>\1</b> \htmlonly[block]</button> <div class=\"content\">\endhtmlonly<ul>"
ALIASES+= "cgalParamDescription{1}=<li>\1</li>"
ALIASES+= "cgalParamType{1}=<li><b>Type: </b>\1</li>"
ALIASES+= "cgalParamDefault{1}=<li><b>%Default: </b>\1</li>"
ALIASES+= "cgalParamExtra{1}=<li><b>Extra: </b>\1</li>"
ALIASES+= "cgalParamNEnd=</ul> \htmlonly[block] </div> \endhtmlonly </td><td></td></tr>"
# This tag can be used to specify a number of word-keyword mappings (TCL only).
# A mapping has the form "name=value". For example adding
# "class=itcl::class" will allow you to use the command class in the

38
Documentation/doc/resources/1.8.4/cgal_stylesheet.css
View File

@ -336,3 +336,41 @@ div.summary
{
width: auto;
}
.collapsible {
background-color: white;
color: #602020;
cursor: pointer;
padding: 3px;
width: 100%;
border: none;
text-align: left;
outline: none;
font: 14px Roboto,sans-serif;
}
.active, .collapsible:hover {
background-color: white;
}
.collapsible:after {
content: '\25B6';
color: #7A93C5;
font-weight: bold;
float: left;
margin-left: -20px;
margin-right: 5px;
}
.active:after {
content: "\25BC";
}
.content {
padding: 0 18px;
color: black;
max-height: 0;
overflow: hidden;
transition: max-height 0.2s ease-out;
background-color: white;
}

16
Documentation/doc/resources/1.8.4/hacks.js
View File

@ -106,3 +106,19 @@ $(document).ready(function() {
}
})();
$(document).ready(function() {
var coll = document.getElementsByClassName("collapsible");
var i;
for (i = 0; i < coll.length; i++) {
coll[i].addEventListener("click", function() {
this.classList.toggle("active");
var content = this.nextElementSibling;
if (content.style.maxHeight){
content.style.maxHeight = null;
} else {
content.style.maxHeight = content.scrollHeight + "px";
}
});
}
});

10
Documentation/doc/resources/1.8.4/menu_version.js
View File

@ -1,15 +1,15 @@
(function() {
'use strict';
var url_re = /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+))\//;
var url_re = /(cgal\.geometryfactory\.com\/CGAL\/doc\/|doc\.cgal\.org\/)(master|latest|(\d\.\d+|\d\.\d+\.\d+)(-beta\d)?)\//;
var url_local = /.*\/doc_output\//;
var current_version_local = '5.1-beta1'
var current_version_local = '5.0.3'
var all_versions = [
'master',
'latest',
'5.1-beta1',
'5.0.2',
'4.14.3',
'5.1-beta2',
'5.0.3',
'4.14.2',
'4.13.2',
'4.12.2',
'4.11.3',

4
Documentation/doc/resources/1.8.4/stylesheet.css
View File

@ -1079,10 +1079,12 @@ dl.citelist dt {
font-weight:bold;
margin-right:10px;
padding:5px;
text-align:right;
width:52px;
}
dl.citelist dd {
margin:2px 0;
margin:2px 0 2px 72px;
padding:5px 0;
}

8
Documentation/doc/scripts/pkglist_filter
View File

@ -1,9 +1,3 @@
#!/bin/sh
if which python2 2>/dev/null >/dev/null; then
exec python2 ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1"
elif which python2.7 2>/dev/null >/dev/null; then
exec python2.7 ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1"
elif which python2.6 2>/dev/null >/dev/null; then
exec python2.6 ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1"
fi
exec ${PYTHON_EXECUTABLE} ${CMAKE_BINARY_DIR}/pkglist_filter.py "$1"

14
Documentation/doc/scripts/pkglist_filter.bat
View File

@ -1,18 +1,6 @@
@echo off
@where /q python
if not errorlevel 1 ( set python=python )
@where /q python2
if not errorlevel 1 ( set python=python2 )
@where /q python2.6
if not errorlevel 1 ( set python=python2.6 )
@where /q python2.7
if not errorlevel 1 ( set python=python2.7 )
:go
%python% ${CMAKE_BINARY_DIR}/pkglist_filter.py %1
${PYTHON_EXECUTABLE} ${CMAKE_BINARY_DIR}/pkglist_filter.py %1
@echo on

12
Documentation/doc/scripts/pkglist_filter.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2
#!/usr/bin/env python3
import codecs
import re
@ -28,10 +28,16 @@ def main(argv):
for l in pkgdesc:
do_print = do_print or re.match(".*cgalPkgDescriptionBegin.*", l)
if(do_print):
sys.stdout.write(l.encode('utf-8'))
if hasattr(sys.stdout, 'buffer'):
sys.stdout.buffer.write(l.encode('utf-8')) #python3
else:
sys.stdout.write(l.encode('utf-8')) #python2
do_print = do_print and (not re.match(".*cgalPkgDescriptionEnd.*", l))
else:
sys.stdout.write(line.encode('utf-8'))
if hasattr(sys.stdout, 'buffer'):
sys.stdout.buffer.write(line.encode('utf-8')) #python3
else:
sys.stdout.write(line.encode('utf-8')) #python2
if __name__ == "__main__":
main(sys.argv)

5
GraphicsView/include/CGAL/Qt/camera_impl.h
View File

@ -1725,6 +1725,11 @@ CGAL_INLINE_FUNCTION
MAT(out, 3, 3) = r3[7];
return 1;
}
#undef MAT
#undef SWAP_ROWS_GLdouble
#undef SWAP_ROWS_DOUBLE
CGAL_INLINE_FUNCTION
int unProject(GLdouble winx, GLdouble winy, GLdouble winz, GLdouble *modelview, GLdouble *projection, int *viewport,
GLdouble *objX,GLdouble *objY,GLdouble *objZ)

7
Installation/CHANGES.md
View File

@ -4,7 +4,7 @@ Release History
[Release 5.1](https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.1)
-----------
Release date: July 2020
Release date: September 2020
### [Tetrahedral Remeshing](https://doc.cgal.org/5.1/Manual/packages.html#PkgTetrahedralRemeshing) (new package)
@ -30,6 +30,11 @@ Release date: July 2020
See also the associated [blog entry](https://www.cgal.org/2020/04/20/Optimal_bounding_box/).
### Installation
- The CGAL\_Core library no longer requires `Boost.Thread`, even if the g++ compiler is used.
- The minimal supported version of Boost is now 1.66.0.
### [Tutorials](https://doc.cgal.org/5.1/Manual/tutorials.html)
- Two new, detailed tutorials have been added:

38
Installation/CMakeLists.txt
View File

@ -382,8 +382,6 @@ include(${CGAL_MODULES_DIR}/CGAL_Macros.cmake)
include(${CGAL_MODULES_DIR}/CGAL_enable_end_of_configuration_hook.cmake)
cgal_setup_module_path()
message( STATUS "CGAL_REFERENCE_CACHE_DIR=${CGAL_REFERENCE_CACHE_DIR}" )
if ( RUNNING_CGAL_AUTO_TEST )
message(STATUS "Operating system:")
execute_process(COMMAND uname -a
@ -392,41 +390,6 @@ if ( RUNNING_CGAL_AUTO_TEST )
ERROR_VARIABLE uname_a)
message(STATUS "${uname_a}")
CGAL_display_compiler_version()
if ( NOT "${CGAL_REFERENCE_CACHE_DIR}" STREQUAL "" )
if ( EXISTS ${CGAL_REFERENCE_CACHE_DIR} )
if ( EXISTS ${CGAL_REFERENCE_CACHE_DIR}/CMakeCache.txt )
message( STATUS "Loading reference cache from ${CGAL_REFERENCE_CACHE_DIR}" )
load_cache( ${CGAL_REFERENCE_CACHE_DIR}
EXCLUDE CGAL_Core_LIBRARY
CGAL_CORE_PACKAGE_DIR
WITH_CGAL_Core
CGAL_INSTALLATION_PACKAGE_DIR
CGAL_MAINTENANCE_PACKAGE_DIR
CGAL_PDB_BINARY_DIR
CGAL_PDB_SOURCE_DIR
CGAL_BINARY_DIR
CGAL_SOURCE_DIR)
# message("List of cache variables:")
## The following lines removes nasty loaded cache values. We do not
## want that the current build tree depends on binaries that were
## build in the reference build tree.
get_property(cache_variables DIRECTORY PROPERTY CACHE_VARIABLES)
foreach(var ${cache_variables})
# get_property(var_value CACHE ${var} PROPERTY VALUE)
# get_property(type CACHE ${var} PROPERTY TYPE)
string(REGEX MATCH "^CGAL(_.*_(DEPENDS|BINARY_DIR)|_.*LIBRARY)$" var_name_matches ${var})
if(var_name_matches)
unset(${var} CACHE)
# else()
# message("${var}:${var_type}=${var_value}")
endif()
endforeach()
endif()
endif()
endif()
endif()
include(CGAL_Common)
@ -916,6 +879,7 @@ if(NOT CGAL_HEADER_ONLY)
else()
install(FILES
${CMAKE_CURRENT_LIST_DIR}/lib/cmake/CGAL/CGALConfig.cmake
${CMAKE_CURRENT_LIST_DIR}/lib/cmake/CGAL/CGALConfigBuildVersion.cmake
${CMAKE_CURRENT_LIST_DIR}/lib/cmake/CGAL/CGALConfigVersion.cmake
DESTINATION ${CGAL_INSTALL_CMAKE_DIR})
if(NOT CGAL_INSTALL_CMAKE_DIR STREQUAL "${CGAL_INSTALL_LIB_DIR}/cmake/CGAL")

2
Installation/cmake/modules/CGAL_Boost_iostreams_support.cmake
View File

@ -35,7 +35,7 @@ if(Boost_IOSTREAMS_FOUND AND NOT TARGET CGAL::Boost_iostreams_support)
if(CMAKE_VERSION VERSION_LESS 3.11)
set_target_properties(CGAL::Boost_iostreams_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_BOOST_IOSTREAMS"
INTERFACE_LINK_LIBRARIES ${Boost_LIB} ${ZLIB_LIBS})
INTERFACE_LINK_LIBRARIES "${Boost_LIB};${ZLIB_LIBS}")
else()
set_target_properties(CGAL::Boost_iostreams_support PROPERTIES
INTERFACE_COMPILE_DEFINITIONS "CGAL_LINKED_WITH_BOOST_IOSTREAMS")

23
Installation/cmake/modules/CGAL_SetupCGAL_CoreDependencies.cmake
View File

@ -53,13 +53,6 @@ endif()
# keyword, or ``PUBLIC`` otherwise.
#
# See the release notes of CGAL-4.10: CGAL_Core now requires
# Boost.Thread, with GNU G++ < 9.1.
if (CMAKE_CXX_COMPILER_ID STREQUAL GNU AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.1)
include(${CMAKE_CURRENT_LIST_DIR}/CGAL_TweakFindBoost.cmake)
find_package( Boost 1.48 REQUIRED COMPONENTS thread system )
endif()
function(CGAL_setup_CGAL_Core_dependencies target)
if(ARGV1 STREQUAL INTERFACE)
set(keyword INTERFACE)
@ -71,20 +64,4 @@ function(CGAL_setup_CGAL_Core_dependencies target)
target_compile_definitions(${target} ${keyword} CGAL_USE_CORE=1)
target_link_libraries( CGAL_Core ${keyword} CGAL::CGAL )
# See the release notes of CGAL-4.10: CGAL_Core now requires
# Boost.Thread, with GNU G++.
if (CMAKE_CXX_COMPILER_ID STREQUAL GNU AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.1)
if(TARGET Boost::thread)
target_link_libraries( CGAL_Core ${keyword} Boost::thread)
else()
# Note that `find_package( Boost...)` must be called in the
# function `CGAL_setup_CGAL_Core_dependencies()` because the
# calling `CMakeLists.txt` may also call `find_package(Boost)`
# between the inclusion of this module, and the call to this
# function. That resets `Boost_LIBRARIES`.
find_package( Boost 1.48 REQUIRED thread system )
target_link_libraries( CGAL_Core ${keyword} ${Boost_LIBRARIES})
endif()
endif()
endfunction()

3
Installation/cmake/modules/CGAL_add_test.cmake
View File

@ -16,6 +16,9 @@ if(NOT POLICY CMP0064)
# Add a fake function to avoid CMake errors
function(cgal_add_compilation_test)
endfunction()
# Add a fake function to avoid CMake errors
function(cgal_setup_test_properties)
endfunction()
# Then return, to exit the file
return()

3
Installation/cmake/modules/CGAL_parse_version_h.cmake
View File

@ -14,5 +14,6 @@ function(cgal_parse_version_h version_h_file name)
MATH(EXPR ${ARGV3} "${CMAKE_MATCH_5}") # minor version without leading 0
set(${ARGV3} "${${ARGV3}}" PARENT_SCOPE)
set(${ARGV4} "${CMAKE_MATCH_6}" PARENT_SCOPE) # patch number
set(${ARGV5} "${CMAKE_MATCH_7}" PARENT_SCOPE) # build number
MATH(EXPR ${ARGV5} "${CMAKE_MATCH_7}") # build number version without leading 0
set(${ARGV5} "${${ARGV5}}" PARENT_SCOPE) # build number
endfunction()

1
Installation/cmake/modules/FindMPFI.cmake
View File

@ -1,4 +1,5 @@
find_package( GMP QUIET )
find_package( MPFR QUIET )
if( GMP_FOUND AND MPFR_FOUND )

34
Installation/include/CGAL/Mesh_3/Mesh_complex_3_in_triangulation_3_fwd.h Normal file
View File

@ -0,0 +1,34 @@
// Copyright (C) 2020 GeometryFactory Sarl
//
// This file is part of CGAL (www.cgal.org)
//
// $URL$
// $Id$
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
//
#ifndef CGAL_MESH_3_MESH_COMPLEX_3_IN_TRIANGULATION_3_FWD_H
#define CGAL_MESH_3_MESH_COMPLEX_3_IN_TRIANGULATION_3_FWD_H
/// \file Mesh_complex_3_in_triangulation_3_fwd.h
/// Forward declarations of the Mesh_3 package.
#ifndef DOXYGEN_RUNNING
namespace CGAL {
// fwdS for the public interface
template <typename Tr,
typename CornerIndex = int,
typename CurveIndex = int>
class Mesh_complex_3_in_triangulation_3;
template<class Tr, bool c3t3_loader_failed>
bool build_triangulation_from_file(std::istream& is,
Tr& tr);
} // CGAL
#endif
#endif /* CGAL_MESH_3_MESH_COMPLEX_3_IN_TRIANGULATION_3_FWD_H */

9
Installation/include/CGAL/config.h
View File

@ -36,8 +36,9 @@
# define WIN64
#endif
#ifdef BOOST_MSVC
#ifdef _MSC_VER
#define _SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING 1
#define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING 1
#endif
#ifdef CGAL_INCLUDE_WINDOWS_DOT_H
@ -296,6 +297,10 @@
#if __cplusplus >= 201402L || _MSVC_LANG >= 201402L
# define CGAL_CXX14 1
#endif
// Same for C++17
#if __cplusplus >= 201703L || _MSVC_LANG >= 201703L
# define CGAL_CXX17 1
#endif
#if defined(BOOST_NO_CXX11_HDR_FUNCTIONAL) || BOOST_VERSION < 105000
#define CGAL_CFG_NO_STD_HASH 1
@ -559,7 +564,7 @@ using std::max;
#define CGAL_NORETURN [[noreturn]]
// Macro to specify [[no_unique_address]] if supported
#if __has_cpp_attribute(no_unique_address)
#if CGAL_CXX11 && __has_cpp_attribute(no_unique_address)
# define CGAL_NO_UNIQUE_ADDRESS [[no_unique_address]]
#else
# define CGAL_NO_UNIQUE_ADDRESS

2
Installation/include/CGAL/version.h
View File

@ -17,7 +17,7 @@
#define CGAL_VERSION_H
#ifndef SWIG
#define CGAL_VERSION 5.1-beta2
#define CGAL_VERSION 5.1-beta3
#define CGAL_GIT_HASH abcdef
#endif
#define CGAL_VERSION_NR 1050100000

10
Installation/lib/cmake/CGAL/CGALConfig.cmake
View File

@ -150,6 +150,7 @@ foreach(cgal_lib ${CGAL_LIBRARIES})
endif()
endforeach()
include(${CGAL_CONFIG_DIR}/CGALConfigVersion.cmake)
#
#
@ -161,15 +162,6 @@ cgal_setup_module_path()
set(CGAL_USE_FILE ${CGAL_MODULES_DIR}/UseCGAL.cmake)
include(${CGAL_MODULES_DIR}/CGAL_target_use_TBB.cmake)
include("${CGAL_MODULES_DIR}/CGAL_parse_version_h.cmake")
cgal_parse_version_h( "${CGAL_INSTALLATION_PACKAGE_DIR}/include/CGAL/version.h"
"CGAL_VERSION_NAME"
"CGAL_MAJOR_VERSION"
"CGAL_MINOR_VERSION"
"CGAL_BUGFIX_VERSION"
"CGAL_BUILD_VERSION")
set(CGAL_VERSION "${CGAL_MAJOR_VERSION}.${CGAL_MINOR_VERSION}.${CGAL_BUGFIX_VERSION}.${CGAL_BUILD_VERSION}")
if( CGAL_DEV_MODE OR RUNNING_CGAL_AUTO_TEST )
# Do not use -isystem for CGAL include paths
set(CMAKE_NO_SYSTEM_FROM_IMPORTED TRUE)

1
Installation/lib/cmake/CGAL/CGALConfigBuildVersion.cmake Normal file
View File

@ -0,0 +1 @@
set(CGAL_BUILD_VERSION 0)

3
Installation/lib/cmake/CGAL/CGALConfigVersion.cmake
View File

@ -1,7 +1,8 @@
set(CGAL_MAJOR_VERSION 5)
set(CGAL_MINOR_VERSION 1)
set(CGAL_BUGFIX_VERSION 0)
set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "5.1-beta2")
include(${CMAKE_CURRENT_LIST_DIR}/CGALConfigBuildVersion.cmake)
set(CGAL_VERSION_PUBLIC_RELEASE_VERSION "5.1-beta3")
set(CGAL_VERSION_PUBLIC_RELEASE_NAME "CGAL-${CGAL_VERSION_PUBLIC_RELEASE_VERSION}")
if (CGAL_BUGFIX_VERSION AND CGAL_BUGFIX_VERSION GREATER 0)

56
Intersections_3/include/CGAL/Intersections_3/internal/Tetrahedron_3_Bounded_3_do_intersect.h
View File

@ -153,31 +153,49 @@ do_intersect(const typename K::Sphere_3 &sp,
template <class K>
inline
typename K::Boolean
do_intersect(const typename K::Tetrahedron_3 &tet,
const typename K::Tetrahedron_3 &sp,
do_intersect(const typename K::Tetrahedron_3 &lh_tet,
const typename K::Tetrahedron_3 &rh_tet,
const K & k)
{
return do_intersect_tetrahedron_bounded(sp, tet, tet[0], k);
return do_intersect_tetrahedron_bounded(lh_tet, rh_tet, lh_tet[0], k);
}
// BBox_3 specific code since it is ok for BBox_3 to degenerate.
template <class K>
inline
typename K::Boolean
do_intersect(const typename K::Tetrahedron_3 &tet,
const CGAL::Bbox_3 &bb,
const K & k)
{
return do_intersect_tetrahedron_bounded(bb, tet, typename K::Point_3(bb.xmin(), bb.ymin(), bb.zmin()), k);
}
template <class K>
inline
typename K::Boolean
do_intersect(const CGAL::Bbox_3 &bb,
inline typename K::Boolean do_intersect(const CGAL::Bbox_3 &aabb,
const typename K::Tetrahedron_3 &tet,
const K & k)
{
return do_intersect_tetrahedron_bounded(bb, tet, typename K::Point_3(bb.xmin(), bb.ymin(), bb.zmin()), k);
const K &k) {
typename K::Construct_triangle_3 tr = k.construct_triangle_3_object();
typename K::Boolean result = false;
typename K::Boolean b = false;
b = do_intersect(aabb, tr(tet[0], tet[1], tet[2]), k);
if (certainly(b)) return b;
if (is_indeterminate(b)) result = b;
b = do_intersect(aabb, tr(tet[1], tet[2], tet[3]), k);
if (certainly(b)) return b;
if (is_indeterminate(b)) result = b;
b = do_intersect(aabb, tr(tet[2], tet[3], tet[0]), k);
if (certainly(b)) return b;
if (is_indeterminate(b)) result = b;
b = do_intersect(aabb, tr(tet[3], tet[0], tet[1]), k);
if (certainly(b)) return b;
if (is_indeterminate(b)) result = b;
b = k.has_on_bounded_side_3_object()(
tet, k.construct_point_3_object()(aabb.xmin(), aabb.ymin(), aabb.zmin()));
if (certainly(b)) return b;
if (is_indeterminate(b)) result = b;
return result;
}
template <class K>
inline typename K::Boolean do_intersect(const typename K::Tetrahedron_3 &tet,
const CGAL::Bbox_3 &bb, const K &k) {
// Swap arguments.
return do_intersect(bb, tet, k);
}
} // namespace internal

36
Kernel_23/test/Kernel_23/test_approximate_dihedral_angle_3.cpp Normal file
View File

@ -0,0 +1,36 @@
#include <CGAL/Simple_cartesian.h>
#include <CGAL/Kernel/global_functions_3.h>
#include <iostream>
#include <utility>
using K = CGAL::Simple_cartesian<double>;
using Point_3 = K::Point_3;
struct query {
Point_3 p;
double expected_angle;
};
int main() {
Point_3 a = {0, 0, 0};
Point_3 b = {0, 1, 0};
Point_3 c = {1, 0, 0};
const query queries[] = {
{ { 1, 0, 0}, 0.},
{ { 1, 0, 1}, 45.},
{ { 0, 0, 1}, 90.},
{ { -1, 0, 1}, 135.},
{ { -1, 0, 0}, 180.},
{ { -1, 0, -1}, -135.},
{ { 0, 0, -1}, -90.},
{ { 1, 0, -1}, -45.},
};
for(auto query: queries) {
const auto& expected = query.expected_angle;
const auto& p = query.p;
auto approx = CGAL::approximate_dihedral_angle(a, b, c, p);
std::cout << approx << " -- " << expected << '\n';
assert( std::abs(approx - expected) < 0.1 );
}
};

4
Maintenance/infrastructure/cgal.geometryfactory.com/crontab
View File

@ -23,9 +23,9 @@ LC_CTYPE=en_US.UTF-8
# The script also updates the manual tools.
# "master" alone
0 21 * * Sun cd $HOME/CGAL/create_internal_release && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/master.git --do-it --beta 2 --public || echo ERROR
0 21 * * Sun cd $HOME/CGAL/create_internal_release && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/master.git --do-it --beta 3 --public || echo ERROR
# "integration"
0 21 * * Mon,Tue,Wed,Thu cd $HOME/CGAL/create_internal_release && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/integration.git $HOME/CGAL/branches/empty-dir --do-it --beta 2 --public || echo ERROR
0 21 * * Mon,Tue,Wed,Thu cd $HOME/CGAL/create_internal_release && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/integration.git $HOME/CGAL/branches/empty-dir --do-it --beta 3 --public || echo ERROR
# from branch 5.0
0 21 * * Sat cd $HOME/CGAL/create_internal_release-5.0-branch && /usr/bin/time scl enable rh-git29 -- $HOME/bin/create_release $HOME/CGAL/branches/CGAL-5.0-branch.git --public --do-it || echo ERROR
# from branch 4.14

15
Maintenance/public_release/announcement/mailing-beta.eml
View File

@ -1,14 +1,14 @@
Subject: CGAL 5.1 Beta 1 Released, Computational Geometry Algorithms Library
Subject: CGAL 5.1 Beta 2 Released, Computational Geometry Algorithms Library
Content-Type: text/plain; charset="utf-8"
Body:
The CGAL Open Source Project is pleased to announce the release 5.1 Beta 1
The CGAL Open Source Project is pleased to announce the release 5.1 Beta 2
of CGAL, the Computational Geometry Algorithms Library.
CGAL version 5.1 Beta 1 is a public testing release. It should provide a
CGAL version 5.1 Beta 2 is a public testing release. It should provide a
solid ground to report bugs that need to be tackled before the release
of the final version of CGAL 5.1 in July.
of the final version of CGAL 5.1 in September.
Besides fixes and general enhancement to existing packages, the following
@ -45,6 +45,11 @@ Optimal Bounding Box (new package)
See also the associated blog entry:
https://www.cgal.org/2020/04/20/Optimal_bounding_box/
Installation
- The CGAL_Core library no longer requires Boost.Thread, even if the
g++ compiler is used.
Tutorials
- Two new, detailed tutorials have been added:
@ -118,7 +123,7 @@ CGAL and the Boost Graph Library (BGL)
uses this alpha expansion graphcut to regularize the borders of a
selected faces on a triangle mesh.
See https://www.cgal.org/2020/06/09/cgal51-beta1/ for a complete list of
See https://www.cgal.org/2020/07/28/cgal51-beta2/ for a complete list of
changes.

11
Mesh_3/doc/Mesh_3/Doxyfile.in
View File

@ -1,19 +1,8 @@
@INCLUDE = ${CGAL_DOC_PACKAGE_DEFAULTS}
# macros to be used inside the code
ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref PMP_\1 \"\1\"</td><td>"
ALIASES += "cgalParamEnd=</td></tr>"
ALIASES += "cgalDescribePolylineType=A polyline is defined as a sequence of points, each pair of contiguous points defines a segment of the polyline. If the first and last points of the polyline are identical, the polyline is closed."
#macros for NamedParameters.txt
ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
ALIASES += "cgalNPEnd=</td></tr>"
INPUT += \
${CGAL_PACKAGE_INCLUDE_DIR}/CGAL/Polyhedral_complex_mesh_domain_3.h \
${CGAL_PACKAGE_INCLUDE_DIR}/CGAL/Mesh_domain_with_polyline_features_3.h

23
Mesh_3/examples/Mesh_3/CMakeLists.txt
View File

@ -133,23 +133,26 @@ else()
message( STATUS "NOTICE: Some examples need the CGAL_ImageIO library, and will not be compiled." )
endif()
if(CGAL_ACTIVATE_CONCURRENT_MESH_3 AND TARGET CGAL::TBB_support AND TARGET ${target})
if(CGAL_ACTIVATE_CONCURRENT_MESH_3 AND TARGET CGAL::TBB_support)
foreach(target
mesh_3D_image_with_features
mesh_3D_image
mesh_polyhedral_domain
mesh_3D_image_variable_size
mesh_3D_image_with_custom_initialization
mesh_two_implicit_spheres_with_balls
mesh_optimization_lloyd_example
mesh_optimization_example
mesh_3D_image_with_features
mesh_implicit_sphere
mesh_polyhedral_complex_sm
mesh_implicit_sphere_variable_size
mesh_polyhedral_domain_sm
mesh_polyhedral_domain_with_lipschitz_sizing
mesh_optimization_example
mesh_optimization_lloyd_example
mesh_polyhedral_complex
mesh_polyhedral_complex_sm
mesh_polyhedral_domain
mesh_polyhedral_domain_sm
mesh_polyhedral_domain_with_features
mesh_3D_image_variable_size)
mesh_polyhedral_domain_with_features_sm
mesh_polyhedral_domain_with_lipschitz_sizing
mesh_two_implicit_spheres_with_balls)
if(TARGET ${target})
target_link_libraries(${target} PUBLIC CGAL::TBB_support)
endif()
endforeach()
endif()

18
Mesh_3/include/CGAL/IO/File_medit.h
View File

@ -17,6 +17,7 @@
#include <CGAL/license/Triangulation_3.h>
#include <CGAL/Mesh_3/config.h>
#include <CGAL/Mesh_3/Mesh_complex_3_in_triangulation_3_fwd.h>
#include <CGAL/utility.h>
#include <CGAL/basic.h>
@ -893,6 +894,23 @@ output_to_medit(std::ostream& os,
}
}
template<typename T3>
void write_MEDIT(std::ostream& os, const T3& t3)
{
CGAL::Mesh_complex_3_in_triangulation_3<T3, int, int> c3t3;
c3t3.triangulation() = t3;
c3t3.rescan_after_load_of_triangulation();
output_to_medit(os, c3t3);
}
template<typename T3>
bool read_MEDIT(std::istream& in, T3& t3)
{
CGAL_assertion(!(!in));
return CGAL::build_triangulation_from_file<T3, true>(in, t3);
}
} // end namespace CGAL
#endif // CGAL_IO_FILE_MEDIT_H

15
Mesh_3/include/CGAL/Mesh_3/C3T3_helpers.h
View File

@ -1224,8 +1224,8 @@ private:
if(update_c3t3)
{
// Update status in c3t3
if(surface != boost::none)
c3t3_.add_to_complex(facet, surface.get());
if((bool)surface)
c3t3_.add_to_complex(facet, *surface);
else
c3t3_.remove_from_complex(facet);
}
@ -1246,7 +1246,7 @@ private:
}
}
return surface;
return surface ? surface : Surface_patch();
}
@ -1572,10 +1572,17 @@ private:
Cell_vector c3t3_cells(const Cell_vector& cells) const
{
Cell_vector c3t3_cells;
#ifdef CGAL_CXX17
std::remove_copy_if(cells.begin(),
cells.end(),
std::back_inserter(c3t3_cells),
std::not_fn(Is_in_c3t3<Cell_handle>(c3t3_)));
#else
std::remove_copy_if(cells.begin(),
cells.end(),
std::back_inserter(c3t3_cells),
std::not1(Is_in_c3t3<Cell_handle>(c3t3_)) );
#endif
return c3t3_cells;
}
@ -2047,7 +2054,7 @@ private:
true); /* update surface centers */
// false means "do not update the c3t3"
if ( c3t3_.is_in_complex(*fit) != (bool)sp ||
((bool)sp && !(c3t3_.surface_patch_index(*fit) == sp.get()) ) )
((bool)sp && !(c3t3_.surface_patch_index(*fit) == *sp) ) )
return false;
}

4
Mesh_3/include/CGAL/Mesh_3/Protect_edges_sizing_field.h
View File

@ -1155,6 +1155,7 @@ insert_balls(const Vertex_handle& vp,
// n = 2(d-sq) / (sp+sq)
// =======================
const FT d_signF = static_cast<FT>(d_sign);
int n = static_cast<int>(std::floor(FT(2)*(d-sq) / (sp+sq))+.5);
// if( minimal_weight_ != 0 && n == 0 ) return;
@ -1180,7 +1181,7 @@ insert_balls(const Vertex_handle& vp,
const Bare_point new_point =
domain_.construct_point_on_curve(cp(vp_wp),
curve_index,
d_sign * d / 2);
d_signF * d / 2);
const int dim = 1; // new_point is on edge
const Index index = domain_.index_from_curve_index(curve_index);
const FT point_weight = CGAL::square(size_(new_point, dim, index));
@ -1230,7 +1231,6 @@ insert_balls(const Vertex_handle& vp,
FT norm_step_size = dleft_frac * step_size;
// Initial distance
FT d_signF = static_cast<FT>(d_sign);
FT pt_dist = d_signF * norm_step_size;
Vertex_handle prev = vp;
const Bare_point& p = cp(c3t3_.triangulation().point(vp));

17
Mesh_3/include/CGAL/Mesh_3/tet_soup_to_c3t3.h
View File

@ -105,13 +105,14 @@ bool build_finite_cells(Tr& tr,
const std::vector<typename Tr::Vertex_handle>& vertex_handle_vector,
boost::unordered_map<std::array<typename Tr::Vertex_handle, 3>,
std::vector<std::pair<typename Tr::Cell_handle, int> > >& incident_cells_map,
const std::map<std::array<int,3>, int>& border_facets,
const std::map<std::array<int,3>, typename Tr::Cell::Surface_patch_index>& border_facets,
const bool verbose)
{
typedef std::array<int, 5> Tet_with_ref; // 4 ids + 1 reference
typedef typename Tr::Vertex_handle Vertex_handle;
typedef typename Tr::Cell_handle Cell_handle;
typedef typename Tr::Cell::Surface_patch_index Surface_patch_index;
CGAL_assertion_code(
typename Tr::Geom_traits::Construct_point_3 cp =
@ -171,7 +172,8 @@ bool build_finite_cells(Tr& tr,
++k;
} while(f[0] != n0);
typename std::map<std::array<int,3>, int>::const_iterator it = border_facets.find(f);
typename std::map<std::array<int,3>, Surface_patch_index>::const_iterator
it = border_facets.find(f);
if(it != border_facets.end())
{
c->set_surface_patch_index(j, it->second);
@ -186,7 +188,7 @@ bool build_finite_cells(Tr& tr,
if(it != border_facets.end())
c->set_surface_patch_index(j, it->second);
else
c->set_surface_patch_index(j, 0);
c->set_surface_patch_index(j, Surface_patch_index());
}
}
}
@ -259,6 +261,8 @@ bool build_infinite_cells(Tr& tr,
// the only finite facet
it->second.push_back(std::make_pair(opp_c, 0));
CGAL_assertion(it->second.size() == 2);
opp_c->set_surface_patch_index(0, c->surface_patch_index(i));
}
#ifdef CGAL_TET_SOUP_TO_C3T3_DEBUG
@ -322,7 +326,7 @@ template<class Tr, bool c3t3_loader_failed>
bool build_triangulation(Tr& tr,
const std::vector<typename Tr::Point>& points,
const std::vector<std::array<int,5> >& finite_cells,
const std::map<std::array<int,3>, int>& border_facets,
const std::map<std::array<int,3>, typename Tr::Cell::Surface_patch_index>& border_facets,
std::vector<typename Tr::Vertex_handle>& vertex_handle_vector,
const bool verbose = false)
{
@ -389,7 +393,7 @@ bool build_triangulation_from_file(std::istream& is,
std::vector<Tet_with_ref> finite_cells;
std::vector<Point_3> points;
std::map<Facet, int> border_facets;
std::map<Facet, typename Tr::Cell::Surface_patch_index> border_facets;
// grab the vertices
int dim;
@ -420,7 +424,8 @@ bool build_triangulation_from_file(std::istream& is,
is >> nf;
for(int i=0; i<nf; ++i)
{
int n1, n2, n3, surface_patch_id;
int n1, n2, n3;
typename Tr::Cell::Surface_patch_index surface_patch_id;
is >> n1 >> n2 >> n3 >> surface_patch_id;
Facet facet;
facet[0] = n1 - 1;

5
Mesh_3/include/CGAL/Mesh_complex_3_in_triangulation_3.h
View File

@ -20,6 +20,7 @@
#include <CGAL/license/Triangulation_3.h>
#include <CGAL/Mesh_3/Mesh_complex_3_in_triangulation_3_fwd.h>
#include <CGAL/disable_warnings.h>
#include <CGAL/iterator.h>
#include <CGAL/Mesh_3/utilities.h>
@ -38,8 +39,8 @@ namespace CGAL {
template <typename Tr,
typename CornerIndex = int,
typename CurveIndex = int>
typename CornerIndex,
typename CurveIndex>
class Mesh_complex_3_in_triangulation_3 :
public Mesh_3::Mesh_complex_3_in_triangulation_3_base<
Tr, typename Tr::Concurrency_tag>

8
Nef_3/include/CGAL/Nef_3/Bounding_box_3.h
View File

@ -73,17 +73,13 @@ public:
}
void extend(const Point_3& p) {
FT q[3];
q[0] = p.x();
q[1] = p.y();
q[2] = p.z();
FT q[3] = { p.x(), p.y(), p.z() };
if(initialized)
Base::extend(q);
else {
initialized = true;
std::copy( q, q + 3, Base::lo );
std::copy( q, q + 3, Base::hi );
*this = Bounding_box_3(q);
}
}
};

7
Nef_3/include/CGAL/Nef_3/SNC_constructor.h
View File

@ -229,9 +229,10 @@ public:
Vertex_handle v = this->sncp()->new_vertex(p , boundary);
CGAL_NEF_TRACEN( v->point());
SM_decorator SD(&*v);
Sphere_point sp[] = { Sphere_point(NT(-x), 0, 0),
Sphere_point(0, NT(-y), 0),
Sphere_point(0, 0, NT(-z)) };
const NT zero(0);
Sphere_point sp[] = { Sphere_point(NT(-x), zero, zero),
Sphere_point(zero, NT(-y), zero),
Sphere_point(zero, zero, NT(-z)) };
/* create box vertices */
SVertex_handle sv[3];

72
Nef_3/include/CGAL/Nef_3/SNC_io_parser.h
View File

@ -56,7 +56,8 @@ namespace Nef_3_internal{
BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(Has_nested_Exact_kernel,Exact_kernel,false)
template <class R,bool has_exact_kernel=Has_nested_Exact_kernel<R>::value, class FT = typename R::RT, class Kernel_tag=typename R::Kernel_tag>
template <class R,bool has_exact_kernel=Has_nested_Exact_kernel<R>::value &&
!std::is_floating_point<typename R::RT>::value, class FT = typename R::RT, class Kernel_tag=typename R::Kernel_tag>
struct Type_converter{
typedef const CGAL::Point_3<R>& Point_3;
typedef const CGAL::Vector_3<R>& Vector_3;
@ -670,8 +671,9 @@ template<typename Tag, typename Kernel> class Geometry_io;
template<typename Kernel>
class Geometry_io<Cartesian_tag, Kernel> {
public:
template <typename EK, typename K> static
typename EK::Point_3 read_point(std::istream& in) {
template <typename EK, typename K, typename Compose_> static
typename EK::Point_3 read_point_impl(std::istream& in, Compose_) {
typedef Fraction_traits<typename K::FT> FracTraits;
typename FracTraits::Type hx, hy, hz, hw;
typename FracTraits::Numerator_type num;
@ -688,8 +690,8 @@ class Geometry_io<Cartesian_tag, Kernel> {
return typename EK::Point_3(hx,hy,hz,hw);
}
template <typename EK, typename K> static
typename EK::Plane_3 read_plane(std::istream& in) {
template <typename EK, typename K, typename Compose_> static
typename EK::Plane_3 read_plane_impl(std::istream& in, Compose_) {
typedef Fraction_traits<typename K::FT> FracTraits;
typename FracTraits::Type a, b, c, d;
typename FracTraits::Numerator_type num;
@ -706,8 +708,32 @@ class Geometry_io<Cartesian_tag, Kernel> {
return typename EK::Plane_3(a,b,c,d);
}
template <typename R> static
void print_point_impl(std::ostream& out, const CGAL::Point_3<R> p) {
template <typename EK, typename K> static
typename EK::Point_3 read_point_impl(std::istream& in, Null_functor) {
typename K::FT hx, hy, hz, hw;
in >> hx >> hy >> hz >> hw;
return typename EK::Point_3(hx,hy,hz,hw);
}
template <typename EK, typename K> static
typename EK::Plane_3 read_plane_impl(std::istream& in, Null_functor) {
typename K::FT a, b, c, d;
in >> a >> b >> c >> d;
return typename EK::Plane_3(a,b,c,d);
}
template <typename EK, typename K> static
typename EK::Point_3 read_point(std::istream& in) {
return read_point_impl<EK,K>(in, typename Fraction_traits<typename K::FT>::Compose());
}
template <typename EK, typename K> static
typename EK::Plane_3 read_plane(std::istream& in) {
return read_plane_impl<EK,K>(in, typename Fraction_traits<typename K::FT>::Compose());
}
template <typename R, typename Decompose_> static
void print_point_impl(std::ostream& out, const CGAL::Point_3<R> p, Decompose_) {
typedef Fraction_traits<typename R::FT> FracTraits;
typedef std::vector<typename FracTraits::Numerator_type> NV;
@ -737,8 +763,8 @@ class Geometry_io<Cartesian_tag, Kernel> {
<< vec[2] << " " << vec[3];
}
template <typename R> static
void print_vector_impl(std::ostream& out, const CGAL::Vector_3<R> p) {
template <typename R, typename Decompose_> static
void print_vector_impl(std::ostream& out, const CGAL::Vector_3<R> p, Decompose_) {
typedef Fraction_traits<typename R::FT> FracTraits;
typedef typename FracTraits::Numerator_type NumType;
typedef std::vector<NumType> NV;
@ -766,8 +792,8 @@ class Geometry_io<Cartesian_tag, Kernel> {
<< vec[2] << " " << NumType(1);
}
template <typename R> static
void print_plane_impl(std::ostream& out, const CGAL::Plane_3<R> p) {
template <typename R, typename Decompose_> static
void print_plane_impl(std::ostream& out, const CGAL::Plane_3<R> p, Decompose_) {
typedef Fraction_traits<typename R::FT> FracTraits;
typedef std::vector<typename FracTraits::Numerator_type> NV;
@ -803,19 +829,37 @@ class Geometry_io<Cartesian_tag, Kernel> {
<< vec[2] << " " << vec[3];
}
template <typename R> static
void print_point_impl(std::ostream& out, const CGAL::Point_3<R> p, Null_functor)
{
out << p.x() << " " << p.y() << " " << p.z() << " " << 1;
}
template <typename R> static
void print_vector_impl(std::ostream& out, const CGAL::Vector_3<R> v, Null_functor)
{
out << v.x() << " " << v.y() << " " << v.z() << " " << 1;
}
template <typename R> static
void print_plane_impl(std::ostream& out, const CGAL::Plane_3<R> p, Null_functor)
{
out << p.a() << " " << p.b() << " " << p.c() << " " << p.d();
}
template <class R> static
void print_point(std::ostream& out, const CGAL::Point_3<R>& p) {
print_point_impl(out, Nef_3_internal::get_point(p) );
print_point_impl(out, Nef_3_internal::get_point(p), typename Fraction_traits<typename R::FT>::Decompose() );
}
template <class R> static
void print_vector(std::ostream& out, const CGAL::Vector_3<R>& v) {
print_vector_impl(out, Nef_3_internal::get_vector(v) );
print_vector_impl(out, Nef_3_internal::get_vector(v), typename Fraction_traits<typename R::FT>::Decompose() );
}
template <class R> static
void print_plane(std::ostream& out, const CGAL::Plane_3<R>& p) {
print_plane_impl(out, Nef_3_internal::get_plane(p) );
print_plane_impl(out, Nef_3_internal::get_plane(p), typename Fraction_traits<typename R::FT>::Decompose() );
}
};

2
Nef_3/include/CGAL/Nef_3/SNC_point_locator.h
View File

@ -563,7 +563,7 @@ public:
Partial_facet pf;
#endif
bool hit = false;
Point_3 eor; // 'end of ray', the latest ray's hit point
Point_3 eor = CGAL::ORIGIN; // 'end of ray', the latest ray's hit point
Objects_along_ray objects = candidate_provider->objects_along_ray(ray);
Objects_along_ray_iterator objects_iterator = objects.begin();
while( !hit && objects_iterator != objects.end()) {

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

@ -24,6 +24,7 @@ if ( CGAL_FOUND )
execution___of__test_nef_3_io_Cartesian
execution___of__test_nef_3_io_Cartesian_Lazy
execution___of__test_nef_3_io_EPEC
execution___of__test_nef_3_io_EPIC
execution___of__test_nef_3_io_Homogeneous
execution___of__test_nef_3_io_Homogenoeus_Lazy
execution___of__test_with_extended_homogeneous

57
Nef_3/test/Nef_3/test_nef_3_io_EPIC.cpp Normal file
View File

@ -0,0 +1,57 @@
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Nef_polyhedron_3.h>
#include <CGAL/Polyhedron_3.h>
#include <CGAL/IO/Nef_polyhedron_iostream_3.h>
#include <fstream>
typedef CGAL::Exact_predicates_inexact_constructions_kernel EPEC;
template <class Kernel>
void test_write_read()
{
typedef CGAL::Nef_polyhedron_3< Kernel > Nef_polyhedron;
typedef CGAL::Polyhedron_3< Kernel > Polyhedron;
typedef typename Kernel::Point_3 Point;
typename Kernel::RT n, d;
std::istringstream str_n("5");
str_n >> n;
std::istringstream str_d("1");
str_d >> d;
Point p(n, 0, 0, d);
Point q(0, n, 0, d);
Point r(0, 0, n, d);
Point s(0, 0, 0, 1);
std::cout << " build...\n";
Polyhedron P;
P.make_tetrahedron( p, q, r, s);
Nef_polyhedron nef_1( P );
std::cout << " write...\n";
std::ofstream out ("temp.nef");
out << std::setprecision(17) << nef_1;
out.close();
std::cout << " read...\n";
std::ifstream in ("temp.nef");
Nef_polyhedron nef_2;
in >> nef_2;
in.close();
std::cout << " check...\n";
assert( nef_1 == nef_2);
}
int main()
{
std::cout << "Testing Exact_predicates_inexact_constructions_kernel\n";
test_write_read<EPEC>();
std::cout << "Testing Simple_cartesian<double>\n";
test_write_read<CGAL::Simple_cartesian<double>>();
return 0;
}

6
Number_types/include/CGAL/Exact_algebraic.h
View File

@ -49,12 +49,10 @@ typedef unspecified_type Exact_algebraic;
#else // not DOXYGEN_RUNNING
#ifdef CGAL_USE_CORE
typedef CORE::Expr Exact_algebraic;
#endif
#ifdef CGAL_USE_LEDA
typedef leda_real Exact_algebraic;
#elif defined CGAL_USE_CORE
typedef CORE::Expr Exact_algebraic;
#endif
#endif

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

@ -68,6 +68,7 @@ if ( CGAL_FOUND )
create_single_source_cgal_program( "to_interval_test.cpp" )
create_single_source_cgal_program( "unsigned.cpp" )
create_single_source_cgal_program( "utilities.cpp" )
find_package( GMP )
if( GMP_FOUND )
create_single_source_cgal_program( "CORE_Expr_ticket_4296.cpp" )
find_package( MPFI )

4
Number_types/test/Number_types/Lazy_exact_nt_new.cpp
View File

@ -98,7 +98,8 @@ void test_lazy_exact_nt() {
#ifdef CGAL_USE_CORE
CGAL_assertion_code(typedef CGAL::Lazy_exact_nt<leda_integer> T1;)
CGAL_assertion_code(typedef CGAL::Lazy_exact_nt<CORE::Expr> T2;)
CGAL_assertion_code(typedef CGAL::Coercion_traits<T1, T2> CT;)
typedef CGAL::Coercion_traits<T1, T2> CT;
CGAL_USE_TYPE(CT);
CGAL_static_assertion((boost::is_same< typename CT::Are_implicit_interoperable,CGAL::Tag_false>::value));
CGAL_static_assertion((boost::is_same< typename CT::Are_explicit_interoperable,CGAL::Tag_false>::value));
#endif
@ -115,4 +116,3 @@ int main() {
#endif
return 0;
}

12
Optimal_bounding_box/doc/Optimal_bounding_box/Doxyfile.in
View File

@ -5,18 +5,6 @@ EXTRACT_ALL = false
HIDE_UNDOC_CLASSES = true
WARN_IF_UNDOCUMENTED = true
# macros to be used inside the code
ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref OBB_\1 \"\1\"</td><td>"
ALIASES += "cgalParamEnd=</td></tr>"
#macros for NamedParameters.txt
ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
ALIASES += "cgalNPEnd=</td></tr>"
MACRO_EXPANSION = YES
EXPAND_ONLY_PREDEF = YES
EXPAND_AS_DEFINED = CGAL_BGL_NP_TEMPLATE_PARAMETERS \

65
Optimal_bounding_box/doc/Optimal_bounding_box/NamedParameters.txt
View File

@ -1,65 +0,0 @@
/*!
\defgroup obb_namedparameters Named Parameters for the package Optimal Bounding Box
\ingroup PkgOptimalBoundingBoxRef
In this package, the optional parameters of all functions are implemented as BGL optional
named parameters (see \ref BGLNamedParameters for more information on how to use them).
Since the parameters of the various functions defined in this package are redundant,
their long descriptions are centralized below.
The sequence of named parameters should start with `CGAL::parameters::`.
`CGAL::parameters::all_default()` can be used to indicate
that default values of optional named parameters must be used.
In the following, we assume that the following types are provided as template parameters
of functions and classes. Note that, for some of these functions,
the type is more specific:
<ul>
<li>`PolygonMesh` is a model of the concept `FaceGraph`</li>.
<li>`GeomTraits` a geometric traits class in which constructions are performed and
predicates evaluated. Everywhere in this package, a \cgal `Kernel` fulfills the requirements.</li>
</ul>
The following named parameters, offered by the package \ref PkgBGL
(see \ref bgl_namedparameters), are used in this package:
\cgalNPTableBegin
\cgalNPBegin{vertex_point_map} \anchor OBB_vertex_point_map
is the property map with the points associated to the vertices of the polygon mesh `pmesh`.\n
<b>Type:</b> a class model of `ReadablePropertyMap` with
`boost::graph_traits<PolygonMesh>::%vertex_descriptor` as key type and
`GeomTraits::Point_3` as value type. \n
<b>Default:</b> \code boost::get(CGAL::vertex_point, pmesh) \endcode
\cgalNPEnd
\cgalNPBegin{point_map} \anchor OBB_point_map
is the property map containing the points associated to the elements of the point range `points`.\n
<b>Type:</b> a class model of `ReadablePropertyMap` with `PointRange::iterator::value_type` as key type
and `geom_traits::Point_3` as value type. \n
<b>Default:</b> \code CGAL::Identity_property_map<geom_traits::Point_3>\endcode
\cgalNPEnd
\cgalNPTableEnd
In addition to these named parameters, this package offers the following named parameters:
\cgalNPTableBegin
\cgalNPBegin{geom_traits} \anchor OBB_geom_traits
is the geometric traits instance in which the mesh processing operation should be performed.\n
<b>Type:</b> a Geometric traits class.\n
<b>Default:</b>
\code typename CGAL::Kernel_traits<
typename boost::property_traits<
typename boost::property_map<PolygonMesh, CGAL::vertex_point_t>::type>::value_type>::Kernel \endcode
\cgalNPEnd
\cgalNPBegin{use_convex_hull} \anchor OBB_use_convex_hull
Parameter used in the construction of oriented bounding box to indicate whether the algorithm should
first extract the extreme points (points that are on the 3D convex hull) of the input data range
to accelerate the computation of the bounding box.
\n
<b>Type:</b> `bool` \n
<b>Default:</b> `true`
\cgalNPEnd
\cgalNPTableEnd
*/

4
Optimal_bounding_box/doc/Optimal_bounding_box/Optimal_bounding_box.txt
View File

@ -94,7 +94,7 @@ and is enabled by default.
\subsection OBBInnOut Input and Output
The input can be a range of 3D points, or a mesh, with a variety of \ref obb_namedparameters "Named Parameters"
The input can be a range of 3D points, or a mesh, with a variety of \ref bgl_namedparameters "Named Parameters"
enabling using further custom inputs.
The result of the algorithm can be retrieved as:
@ -177,7 +177,7 @@ from the eight points.
\subsection OBBExampleNP Using Named Parameters
The following example illustrates how to use \ref obb_namedparameters "Named Parameters"
The following example illustrates how to use \ref bgl_namedparameters "Named Parameters"
to efficiently compute the oriented bounding box of a mesh whose vertices' positions are
modified on the fly.

2
Optimal_bounding_box/doc/Optimal_bounding_box/PackageDescription.txt
View File

@ -35,7 +35,7 @@
\cgalCRPSection{Parameters}
Optional parameters of the functions of this package are implemented as \ref BGLNamedParameters.
The page \ref obb_namedparameters describes their usage and provides a list of the parameters
The page \ref bgl_namedparameters describes their usage and provides a list of the parameters
that are used in this package.
\cgalCRPSection{Concepts}

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

@ -288,27 +288,34 @@ void construct_oriented_bounding_box(const PointRange& points,
/// \tparam Output either the type `Aff_transformation_3` of the traits class,
/// or `std::array<Point, 8>` with `Point` being equivalent to the type `%Point_3` of the traits class,
/// or a model of `MutableFaceGraph`
/// \tparam NamedParameters a sequence of \ref obb_namedparameters "Named Parameters"
/// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
///
/// \param points the input range
/// \param out the resulting array of points or affine transformation
/// \param np an optional sequence of \ref obb_namedparameters "Named Parameters" among the ones listed below:
/// \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{point_map}
/// a model of `ReadablePropertyMap` with value type the type `%Point_3` of the traits class.
/// If this parameter is omitted, `CGAL::Identity_property_map<%Point_3>` is used.
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits}
/// a geometric traits class instance, model of the concept `OrientedBoundingBoxTraits_3`.
/// %Default is a default construction object of type `CGAL::Oriented_bounding_box_traits_3<K>`
/// where `K` is a kernel type deduced from the point type.
/// \cgalParamEnd
/// \cgalParamBegin{use_convex_hull}
/// a Boolean value to indicate whether the algorithm should first extract the so-called extreme
/// points of the data range (i.e. construct the convex hull) to reduce the input data range
/// and accelerate the algorithm. %Default is `true`.
/// \cgalParamEnd
/// \cgalParamNBegin{point_map}
/// \cgalParamDescription{a property map associating points to the elements of the point range}
/// \cgalParamType{a model of `ReadablePropertyMap` with value type `geom_traits::Point_3`}
/// \cgalParamDefault{`CGAL::Identity_property_map<geom_traits::Point_3>`}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{geom_traits}
/// \cgalParamDescription{an instance of a geometric traits class}
/// \cgalParamType{a model of `OrientedBoundingBoxTraits_3`}
/// \cgalParamDefault{a default-constructed object of type `CGAL::Oriented_bounding_box_traits_3<K>`,
/// where `K` is a kernel type deduced from the point type.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{use_convex_hull}
/// \cgalParamDescription{Parameter used in the construction of oriented bounding box to indicate
/// whether the algorithm should first extract the extreme points (points
/// that are on the 3D convex hull) of the input data range
/// to accelerate the computation of the bounding box.}
/// \cgalParamType{Boolean}
/// \cgalParamDefault{`true`}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
template <typename PointRange,
@ -379,28 +386,37 @@ void oriented_bounding_box(const PointRange& points,
/// \tparam Output either the type `Aff_transformation_3` of the traits class,
/// or `std::array<Point, 8>` with `Point` being equivalent to the type `%Point_3` of the traits class,
/// or a model of `MutableFaceGraph`
/// \tparam NamedParameters a sequence of \ref obb_namedparameters "Named Parameters"
/// \tparam NamedParameters a sequence of \ref bgl_namedparameters "Named Parameters"
///
/// \param pmesh the input mesh
/// \param out the resulting array of points or affine transformation
/// \param np an optional sequence of \ref obb_namedparameters "Named Parameters" among the ones listed below:
/// \param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
///
/// \cgalNamedParamsBegin
/// \cgalParamBegin{vertex_point_map}
/// the property map with the points associated to the vertices of `pmesh`.
/// If this parameter is omitted, an internal property map for
/// `CGAL::vertex_point_t` must be available in `PolygonMesh`.
/// \cgalParamEnd
/// \cgalParamBegin{geom_traits}
/// a geometric traits class instance, model of the concept `OrientedBoundingBoxTraits_3`.
/// %Default is a default construction object of type `CGAL::Oriented_bounding_box_traits_3<K>`
/// where `K` is a kernel type deduced from the point type.
/// \cgalParamEnd
/// \cgalParamBegin{use_convex_hull}
/// a Boolean value to indicate whether the algorithm should first extract the so-called extreme
/// points of the data range (i.e. construct the convex hull) to reduce the input data range
/// and accelerate the algorithm. %Default is `true`.
/// \cgalParamEnd
/// \cgalParamNBegin{vertex_point_map}
/// \cgalParamDescription{a property map associating points to the vertices of `pmesh`}
/// \cgalParamType{a class model of `ReadablePropertyMap` 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`
/// should be available for the vertices of `pmesh`.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{geom_traits}
/// \cgalParamDescription{an instance of a geometric traits class}
/// \cgalParamType{a model of `OrientedBoundingBoxTraits_3`}
/// \cgalParamDefault{a default-constructed object of type `CGAL::Oriented_bounding_box_traits_3<K>`,
/// where `K` is a kernel type deduced from the point type.}
/// \cgalParamNEnd
///
/// \cgalParamNBegin{use_convex_hull}
/// \cgalParamDescription{Parameter used in the construction of oriented bounding box to indicate
/// whether the algorithm should first extract the extreme points (points
/// that are on the 3D convex hull) of the input data range
/// to accelerate the computation of the bounding box.}
/// \cgalParamType{Boolean}
/// \cgalParamDefault{`true`}
/// \cgalParamNEnd
/// \cgalNamedParamsEnd
///
template <typename PolygonMesh,

1
Partition_2/include/CGAL/Partition_2/Triangulation_indirect_traits_2.h
View File

@ -113,6 +113,7 @@ template <class Circulator>
class Construct_circulator_2
{
public:
typedef Circulator result_type;
Circulator operator()(Circulator p1) const { return p1; }
};

8
Periodic_3_triangulation_3/include/CGAL/internal/Periodic_3_Delaunay_triangulation_remove_traits_3.h
View File

@ -40,6 +40,14 @@ public:
using Base::operator();
template<typename F>
struct result : Base::template result<F> {};
template<typename F>
struct result<F(Point_3)> {
typedef const Point_3& type;
};
const Point_3& operator()(const Point_3& p) const { return p; }
};

8
Periodic_3_triangulation_3/include/CGAL/internal/Periodic_3_regular_triangulation_remove_traits_3.h
View File

@ -49,6 +49,14 @@ public:
using Base::operator(); // for K::Weighted_point_3 to Point_3
template<typename F>
struct result : Base::template result<F> {};
template<typename F>
struct result<F(Weighted_point_3)> {
typedef Point_3 type;
};
Point_3 operator()(const Weighted_point_3& wp) const {
return std::make_pair(operator()(wp.first), wp.second /* offset */);
}

12
Point_set_3/doc/Point_set_3/Doxyfile.in
View File

@ -1,14 +1,2 @@
@INCLUDE = ${CGAL_DOC_PACKAGE_DEFAULTS}
PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - 3D Point Set"
# macros to be used inside the code
ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref PSP_\1 \"\1\"</td><td>"
ALIASES += "cgalParamEnd=</td></tr>"
#macros for NamedParameters.txt
ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
ALIASES += "cgalNPEnd=</td></tr>"

11
Point_set_3/include/CGAL/Point_set_3.h
View File

@ -947,13 +947,12 @@ public:
/*!
\brief Returns a sequence of \ref psp_namedparameters "Named Parameters" for Point Set Processing algorithms.
\brief Returns a sequence of \ref bgl_namedparameters "Named Parameters" to be used in Point Set Processing algorithms.
\cgalNamedParamsBegin
\cgalParamBegin{point_map} contains the point map (see `point_map()`)\cgalParamEnd
\cgalParamBegin{normal_map} contains the normal map (see `normal_map()`)\cgalParamEnd
\cgalParamBegin{geom_traits} contains the kernel `typename Kernel_traits<Point>`::`Kernel`\cgalParamEnd
\cgalNamedParamsEnd
The following named parameters are used:
- `point_map`: contains the point property map (see `point_map()`)
- `normal_map`: contains the normal map (see `normal_map()`)
- `geom_traits`: contains the kernel `typename Kernel_traits<Point>`::`Kernel`
\warning this method does not check if the normal map was
instanciated or not. The normal map named parameter should not be

12
Point_set_processing_3/doc/Point_set_processing_3/Doxyfile.in
View File

@ -3,17 +3,5 @@
PROJECT_NAME = "CGAL ${CGAL_DOC_VERSION} - Point Set Processing"
EXCLUDE_PATTERNS += property_map.h
# macros to be used inside the code
ALIASES += "cgalNamedParamsBegin=<dl class=\"params\"><dt>Named Parameters</dt><dd> <table class=\"params\">"
ALIASES += "cgalNamedParamsEnd=</table> </dd> </dl>"
ALIASES += "cgalParamBegin{1}=<tr><td class=\"paramname\">\ref PSP_\1 \"\1\"</td><td>"
ALIASES += "cgalParamEnd=</td></tr>"
#macros for NamedParameters.txt
ALIASES += "cgalNPTableBegin=<dl class=\"params\"><dt></dt><dd> <table class=\"params\">"
ALIASES += "cgalNPTableEnd=</table> </dd> </dl>"
ALIASES += "cgalNPBegin{1}=<tr><td class=\"paramname\">\1 </td><td>"
ALIASES += "cgalNPEnd=</td></tr>"
EXPAND_AS_DEFINED = CGAL_BGL_NP_TEMPLATE_PARAMETERS \
CGAL_BGL_NP_CLASS

280
Point_set_processing_3/doc/Point_set_processing_3/NamedParameters.txt
View File

@ -1,280 +0,0 @@
/*!
\defgroup psp_namedparameters Named Parameters for Point Set Processing
\ingroup PkgPointSetProcessing3Ref
In this package, all functions optional parameters are implemented as BGL optional named parameters (see \ref BGLNamedParameters for more information on how to use them).
Since the parameters of the various point set processing functions defined in this
package are redundant, their long descriptions are centralized below.
In the following, we assume that the following types are provided as template parameters of point set processing functions and classes. Note that, for some of these functions, the type is more specific.
<ul>
<li>`PointRange` is a model of `Range`. The value type of its iterator is the key type of the related property maps (see below).</li>
<li>`GeomTraits` a geometric traits class in which constructions are performed and predicates evaluated. Everywhere in this package, a \cgal `Kernel` fulfills the requirements.</li>
</ul>
`CGAL::parameters::all_default()` can be used to indicate
that default values of optional named parameters must be used.
Here is the list of the named parameters available in this package:
\cgalNPTableBegin
\cgalNPBegin{geom_traits} \anchor PSP_geom_traits
the geometric traits instance in which the point set processing operation should be performed.\n
\b Type: a Geometric traits class.\n
\b Default \b type: is
\code
typename CGAL::Kernel_traits<point_map::value_type>::Kernel
\endcode
\cgalNPEnd
\cgalNPBegin{point_map} \anchor PSP_point_map
is the property map containing the points associated to the elements of the point range `points`.\n
\b Type: a class model of `ReadablePropertyMap` with
`PointRange::iterator::value_type` as key type and
`geom_traits::Point_3` as value type. \n
<b>Default value</b>: \code CGAL::Identity_property_map<geom_traits::Point_3>\endcode
\cgalNPEnd
\cgalNPBegin{normal_map} \anchor PSP_normal_map
is the property map containing the normal vectors associated to the elements of the point range `points`.\n
\b Type: a class model of `ReadablePropertyMap` with
`PointRange::iterator::value_type` as key type and
`geom_traits::Vector_3` as value type. \n
No default value.
\cgalNPEnd
\cgalNPBegin{diagonalize_traits} \anchor PSP_diagonalize_traits
is the solver used for diagonalizing covariance matrices.\n
\b Type: a class model of `DiagonalizeTraits`.\n
\b Default: `CGAL::Eigen_diagonalize_traits` if \ref thirdpartyEigen "Eigen" 3.2 (or greater) is available and `CGAL_EIGEN3_ENABLED` is defined.\n
\cgalNPEnd
\cgalNPBegin{svd_traits} \anchor PSP_svd_traits
is the linear algebra algorithm required by the jet fitting method. For more information, please refer to the documentation of `CGAL::Monge_via_jet_fitting`.\n
\b Type: a class fitting the requirements of `CGAL::Monge_via_jet_fitting`.\n
\b Default: if \ref thirdpartyEigen "Eigen" 3.2 (or greater) is available and `CGAL_EIGEN3_ENABLED` is defined, then `CGAL::Eigen_svd` is used.\n
\cgalNPEnd
\cgalNPBegin{callback} \anchor PSP_callback
is a mechanism to get feedback on the advancement of the algorithm while it's running and to interrupt it if needed. It is called regularly when the algorithm is running: the current advancement (between 0. and 1.) is passed as parameter. If it returns `true`, then the algorithm continues its execution normally; if it returns `false`, the algorithm is stopped.\n
The callback will be copied and therefore needs to be lightweight.\n
Note that when a callback is run on a parallelized algorithm with `CGAL::Parallel_tag`, it is called asynchronously on a separate thread and shouldn't access or modify the variables that are parameters of the algorithm.\n
\b Type: `std::function<bool(double)>`.\n
\b Default: empty function.\n
\cgalNPEnd
\cgalNPBegin{query_point_map} \anchor PSP_query_point_map
is the property map containing the points associated to the elements of the point range `queries`.\n
\b Type: a class model of `ReadablePropertyMap` with
`PointRange::iterator::value_type` as key type and
`geom_traits::Point_3` as value type. \n
<b>Default value</b>: \code CGAL::Identity_property_map<geom_traits::Point_3>\endcode
\cgalNPEnd
\cgalNPBegin{sharpness_angle} \anchor PSP_sharpness_angle
controls the sharpness of the result. The larger the value is, the smoother the result will be.
The range of possible value is [0, 90].\n
\b Type: floating scalar value\n
<b>Default value</b>: `30.`
\cgalNPEnd
\cgalNPBegin{edge_sensitivity} \anchor PSP_edge_sensitivity
controls the priority of points inserted along sharp features. Larger
values of edge-sensitivity give higher priority to inserting points
along sharp features. The range of possible values is `[0, 1]`. \n
\b Type: floating scalar value\n
<b>Default value</b>: `1`.
\cgalNPEnd
\cgalNPBegin{neighbor_radius} \anchor PSP_neighbor_radius
is the spherical neighborhood radius.\n
\b Type: floating scalar value\n
<b>Default value</b>: `-1`, in which case it is not used.
\cgalNPEnd
\cgalNPBegin{number_of_output_points} \anchor PSP_number_of_output_points
is the number of output points to generate.\n
\b Type: \c unsigned \c int \n
<b>Default value</b>: `1000`
\cgalNPEnd
\cgalNPBegin{size} \anchor PSP_size
maximum cluster size for hierarchical clustering. Must be strictly greather than 0.\n
\b Type: \c unsigned \c int \n
<b>Default value</b>: `10`
\cgalNPEnd
\cgalNPBegin{maximum_variation} \anchor PSP_maximum_variation
maximum cluster size for hierarchical clustering. Must be strictly greather than 0.\n
\b Type: \c unsigned \c int \n
<b>Default value</b>: `10`
\cgalNPEnd
\cgalNPBegin{degree_fitting} \anchor PSP_degree_fitting
is the degree of fitting (see `CGAL::Monge_via_jet_fitting`).\n
\b Type: \c unsigned \c int \n
<b>Default value</b>: `2`
\cgalNPEnd
\cgalNPBegin{degree_monge} \anchor PSP_degree_monge
is the Monge degree (see `CGAL::Monge_via_jet_fitting`).\n
\b Type: \c unsigned \c int \n
<b>Default value</b>: `2`
\cgalNPEnd
\cgalNPBegin{threshold_distance} \anchor PSP_threshold_distance
is the minimum distance for a point to be considered as outlier
(distance here is the square root of the average squared distance to K nearest neighbors).\n
\b Type: floating scalar value\n
<b>Default value</b>: `0`
\cgalNPEnd
\cgalNPBegin{threshold_percent} \anchor PSP_threshold_percent
is the maximum percentage (between 0 and 100) of points to remove in `remove_outliers()`.\n
\b Type: floating scalar value\n
<b>Default value</b>: `10`
\cgalNPEnd
\cgalNPBegin{attraction_factor} \anchor PSP_attraction_factor
multiplication factor used for adjacency computations.
\b Type: floating scalar value\n
<b>Default value</b>: `3`
\cgalNPEnd
\cgalNPBegin{plane_map} \anchor PSP_plane_map
is the property map containing the planes associated to the elements of the plane range `planes`.\n
\b Type: a class model of `ReadablePropertyMap` with
`PlaneRange::iterator::value_type` as key type and
`geom_traits::Plane_3` as value type. \n
<b>Default value</b>: \code CGAL::Identity_property_map<geom_traits::Plane_3>\endcode
\cgalNPEnd
\cgalNPBegin{plane_index_map} \anchor PSP_plane_index_map
is the property map that associates the index of a point in the input range to the index of plane (-1 if
point is not assigned to a plane).\n
\b Type: a class model of `ReadablePropertyMap` with
`std::size_t` as key type and
`int` as value type. \n
No default value.
\cgalNPEnd
\cgalNPBegin{select_percentage} \anchor PSP_select_percentage
percentage of points to retain (between 0 and 100) in `wlop_simplify_and_regularize_point_set()`.\n
\b Type: floating scalar value\n
<b>Default value</b>: 5.
\cgalNPEnd
\cgalNPBegin{number_of_iterations} \anchor PSP_number_of_iterations
number of iterations to solve the optimsation problem in `wlop_simplify_and_regularize_point_set()`.\n
\b Type: \c unsigned \c int \n
<b>Default value</b>: 35.
\cgalNPEnd
\cgalNPBegin{require_uniform_sampling} \anchor PSP_require_uniform_sampling
turn on or off an optional preprocessing of `wlop_simplify_and_regularize_point_set()`, which will
give better result if the distribution of the input points is highly non-uniform.\n
\b Type: `bool`\n
<b>Default value</b>: `false`
\cgalNPEnd
\cgalNPBegin{point_is_constrained_map} \anchor PSP_point_is_constrained_map
is the property map containing information about points being constrained or not.
Constrained points are left unaltered and are used as seeds in `mst_orient_normals()`.\n
\b Type: a class model of `ReadablePropertyMap` with
`PointRange::iterator::value_type` as key type and
`bool` as value type. \n
<b>Default value</b>: a property map with only the highest point constrained.
\cgalNPEnd
\cgalNPBegin{number_of_samples} \anchor PSP_number_of_samples
is the number of input points used for computation.\n
\b Type: \c unsigned \c int \n
<b>Default value</b>: `200`
\cgalNPEnd
\cgalNPBegin{accuracy} \anchor PSP_accuracy
is the wanted output accuracy, expressed in scene units.\n
\b Type: floating scalar value\n
<b>Default value</b>: `5.00`
\cgalNPEnd
\cgalNPBegin{maximum_normal_deviation} \anchor PSP_maximum_normal_deviation
is the maximum angle between the normals of a pair of points, expressed in degrees.\n
\b Type: floating scalar value\n
<b>Default value</b>: `90.00`
\cgalNPEnd
\cgalNPBegin{overlap} \anchor PSP_overlap
is the expected overlap ratio (between 0 and 1) between two points sets to register.\n
\b Type: floating scalar value\n
<b>Default value</b>: `0.20`
\cgalNPEnd
\cgalNPBegin{maximum_running_time} \anchor PSP_maximum_running_time
is the maximum time (in seconds) allowed to the function before ending and returning the best solution found so far.\n
\b Type: floating scalar value\n
<b>Default value</b>: `1000`
\cgalNPEnd
\cgalNPBegin{transformation} \anchor PSP_transformation
is the transformation to be applied to the point set before the function starts to further process.\n
\b Type: Aff_transformation_3\n
No default value.
\cgalNPEnd
\cgalNPBegin{point_set_filters} \anchor PSP_point_set_filters
is the chain of filters to be applied to the point set.\n
\b Type: a model of `Range` with `CGAL::pointmatcher::ICP_config` as value type.\n
No default value.
\cgalNPEnd
\cgalNPBegin{matcher} \anchor PSP_matcher
is the method used for matching (linking) the point set to the reference point set.\n
\b Type: a model of `CGAL::pointmatcher::ICP_config`\n
No default value.
\cgalNPEnd
\cgalNPBegin{outlier_filters} \anchor PSP_outlier_filters
is the chain of filters to be applied to the matched (linked) point set after each processing iteration of the registration to reject the outliers for the next iteration.\n
\b Type: a model of `Range` with `CGAL::pointmatcher::ICP_config` as value type.\n
No default value.
\cgalNPEnd
\cgalNPBegin{error_minimizer} \anchor PSP_error_minimizer
is the error minimizer that computes a transformation matrix such as to minimize the error between the point sets in registration process.\n
\b Type: a model of `CGAL::pointmatcher::ICP_config`\n
No default value.
\cgalNPEnd
\cgalNPBegin{transformation_checkers} \anchor PSP_transformation_checkers
is the chain of transformation checkers that can stop the iteration depending on the conditions it defines.\n
\b Type: a model of `Range` with `CGAL::pointmatcher::ICP_config` as value type.\n
No default value.
\cgalNPEnd
\cgalNPBegin{inspector} \anchor PSP_inspector
is the inspector that allows to log data at different steps of the running algorithm to allow analysis.\n
\b Type: a model of `CGAL::pointmatcher::ICP_config`\n
No default value.
\cgalNPEnd
\cgalNPBegin{logger} \anchor PSP_logger
is for logging information regarding the process.\n
\b Type: a model of `CGAL::pointmatcher::ICP_config`\n
No default value.
\cgalNPBegin{adjacencies} \anchor PSP_adjacencies
is an output iterator used to store adjacencies.\n
\b Type: a class model of `OutputIterator` that accepts objects of
type `std::pair<std::size_t, std::size_t>`. \n
<b>Default value</b>: `CGAL::Emptyset_iterator`.
\cgalNPEnd
\cgalNPTableEnd
*/

6
Point_set_processing_3/doc/Point_set_processing_3/Point_set_processing_3.txt
View File

@ -68,8 +68,7 @@ on how to upgrade from the outdated API.
Named parameters are used to deal with optional parameters. The page
\ref BGLNamedParameters explains the rationale and API in general.
The page \ref psp_namedparameters describes their usage
and provides a list of the parameters that are used in this package.
The page \ref bgl_namedparameters describes their usage.
\subsection Point_set_processing_3PropertyMaps Property Maps
@ -172,8 +171,7 @@ The following functions are available:
All of these functions (with the exception of the LAS format) can read
and write either points alone or points with normals (depending on
whether the [normal_map](@ref PSP_normal_map) is provided by the user
or not).
whether the `normal_map` named parameter is used by the user or not).
Note that the %PLY format handles both ASCII and binary formats. In
addition, %PLY and %LAS are extensible formats that can embed additional

16
Point_set_processing_3/include/CGAL/IO/read_las_points.h
View File

@ -428,12 +428,20 @@ bool read_las_points_with_properties (std::istream& stream,
\param stream input stream.
\param output output iterator over points.
\param np optional sequence of \ref psp_namedparameters "Named Parameters" among the ones listed below.
\param np an optional sequence of \ref bgl_namedparameters "Named Parameters" among the ones listed below
\cgalNamedParamsBegin
\cgalParamBegin{point_map} a model of `WritablePropertyMap` with value type `geom_traits::Point_3`.
If this parameter is omitted, `CGAL::Identity_property_map<geom_traits::Point_3>` is used.\cgalParamEnd
\cgalParamBegin{geom_traits} an instance of a geometric traits class, model of `Kernel`\cgalParamEnd
\cgalParamNBegin{point_map}
\cgalParamDescription{a property map associating points to the elements of the point range}
\cgalParamType{a model of `WritablePropertyMap` with value type `geom_traits::Point_3`}
\cgalParamDefault{`CGAL::Identity_property_map<geom_traits::Point_3>`}
\cgalParamNEnd
\cgalParamNBegin{geom_traits}
\cgalParamDescription{an instance of a geometric traits class}
\cgalParamType{a model of `Kernel`}
\cgalParamDefault{a \cgal Kernel deduced from the point type, using `CGAL::Kernel_traits`}
\cgalParamNEnd
\cgalNamedParamsEnd
\return true on success.

Some files were not shown because too many files have changed in this diff Show More