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

Fix a number of issues in CHANGES.md-CGAL 5.1 and add links

This commit is contained in:
Mael Rouxel-Labbé 2020-05-09 11:18:38 +02:00
parent aa8d809fc4
commit afade6d87a
1 changed files with 169 additions and 145 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

296
Installation/CHANGES.md
View File

@ -2,152 +2,83 @@ Release History
=============== ===============
[Release 5.1](https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.1) [Release 5.1](https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.1)
-----------
### 3D Fast Intersection and Distance Computation Release date: July 2020
- The introduction of the usage of the search tree by default for all distance queries
in the 5.0 release was actually not lazy contrary to what was announced. The behavior of the ### [Surface Mesh Topology](https://doc.cgal.org/5.1/Manual/packages.html#PkgSurfaceMeshTopologySummary) (new package)
search tree is now the following: it will be used except if an explicit call to `do_not_accelerate_distance_queries()`
is made. The construction of the search tree (once insertion of primitives is done) will be triggered by the first - This package enables the computation of some topological invariants of surfaces, such as:
distance query or by an explicit call to `accelerate_distance_queries()`. - test if two (closed) curves on a combinatorial surface are homotopic. Users can choose
- **Breaking change**: `accelerate_distance_queries()` and `do_not_accelerate_distance_queries()` are not longer `const` functions. between free homotopy and homotopy with fixed endpoints;
- test is a curve is contractible;
- compute shortest non-contractible cycles on a surface, with or without weights on edges.
### [Optimal Bounding Box](https://doc.cgal.org/5.1/Manual/packages.html#PkgOptimalBoundingBox) (new package)
### Optimal Bounding Box (new package)
- This package implements an optimization algorithm that aims to construct a close approximation - This package implements an optimization algorithm that aims to construct a close approximation
of the *optimal bounding box* of a mesh or a point set, which is defined as the smallest of the *optimal bounding box* of a mesh or a point set, which is defined as the smallest
(in terms of volume) bounding box that contains a given mesh or point set. (in terms of volume) bounding box that contains a given mesh or point set.
### 2D and 3D Linear Geometry Kernel ### [2D and 3D Linear Geometry Kernel](https://doc.cgal.org/5.1/Manual/packages.html#PkgKernel23)
- Add `CompareSignedDistanceToLine_2` in the 2D/3D Kernel concept to compare
- Added the functor [`CompareSignedDistanceToLine_2`](https://doc.cgal.org/5.1/Kernel_23/classKernel_1_1CompareSignedDistanceToLine__2.html)
to the 2D/3D [`Kernel`](https://doc.cgal.org/5.1/Kernel_23/classKernel.html) concept to compare
the signed distance of two points to a line, or the line passing through two given points. the signed distance of two points to a line, or the line passing through two given points.
Corresponding functors in the model (`Compare_signed_distance_to_line_2`) are also added. Corresponding functors in the model ([`Compare_signed_distance_to_line_2`](https://doc.cgal.org/5.1/Kernel_23/classKernel.html#a066d07dd592ac36ba7ee90988abd349f)) are also added.
### 2D Triangulations ### [dD Geometry Kernel](https://doc.cgal.org/5.1/Manual/packages.html#PkgKernelD)
- Add function `split_subconstraint_graph_into_constraints()` to
`Constrained_triangulation_plus_2` to initialize the constraints
from a soup of disconnected segments that should first be split
into polylines.
### 3D Convex Hulls - The kernels [`Epick_d`](https://doc.cgal.org/5.1/Kernel_d/structCGAL_1_1Epick__d.html)
- The long-deprecated function `CGAL::convex_hull_3_to_polyhedron_3()` has been removed. and [`Epeck_d`](https://doc.cgal.org/5.1/Kernel_d/structCGAL_1_1Epeck__d.html) gain two new functors:
The function `CGAL::convex_hull_3_to_face_graph()` should be used instead. [`Power_side_of_bounded_power_sphere_d`](https://doc.cgal.org/5.1/Kernel_d/classCGAL_1_1Epeck__d_1_1Power__side__of__bounded__power__sphere__d.html)
and [`Compute_squared_radius_smallest_orthogonal_sphere_d`](https://doc.cgal.org/5.1/Kernel_d/classCGAL_1_1Epeck__d_1_1Compute__squared__radius__smallest__orthogonal__sphere__d.html).
Those are essential for the computation of weighted alpha-complexes.
### dD Spatial Searching ### [CGAL and the Boost Graph Library (BGL)](https://doc.cgal.org/5.1/Manual/packages.html#PkgBGL)
- The kd-tree can now be built in parallel: `CGAL::Kd_tree::build()` - Added the function [`alpha_expansion_graphcut()`](https://doc.cgal.org/5.1/BGL/group__PkgBGLPartition.html#ga79c3f58b577af51d1140450729d38f22),
which regularizes a multi-label partition over a user-defined graph.
- Added the function [`regularize_face_selection_borders()`](https://doc.cgal.org/5.1/BGL/group__PkgBGLSelectionFct.html#gac71322b0cc7d7d59447531d5e5e345b6),
which uses this alpha expansion graphcut to regularize the borders of a selected faces on a triangle mesh.
- Added the function [`set_triangulation_ids()`](https://doc.cgal.org/5.1/BGL/group__BGLGraphExternalIndices.html#ga1a22cf8bdde32fcdf1a4a78966eed630),
which must be used to initialize vertex, edge, and face indices of a triangulation meant to be used with BGL algorithms.
### [3D Fast Intersection and Distance Computation](https://doc.cgal.org/5.1/Manual/packages.html#PkgAABBTree)
- The behavior of the internal search tree used to accelerate distance queries has changed:
usage of the internal search tree will now be enabled by default, and its construction
will be triggered by the first distance query. Automatic construction and usage can be disabled
by calling [`do_not_accelerate_distance_queries()`](https://doc.cgal.org/5.1/AABB_tree/classCGAL_1_1AABB__tree.html#abde62f52ccdf411847151aa5000ba4a4)
before the first distance query, and the tree can be built at any moment by calling
[`accelerate_distance_queries()`](https://doc.cgal.org/5.1/AABB_tree/classCGAL_1_1AABB__tree.html#a5d3877d3f2afbd09341eb4b8c230080b).
- **Breaking change**: [`accelerate_distance_queries()`](https://doc.cgal.org/5.1/AABB_tree/classCGAL_1_1AABB__tree.html#a5d3877d3f2afbd09341eb4b8c230080b)
and [`do_not_accelerate_distance_queries()`](https://doc.cgal.org/5.1/AABB_tree/classCGAL_1_1AABB__tree.html#abde62f52ccdf411847151aa5000ba4a4)
are no longer `const` functions.
### [dD Spatial Searching](https://doc.cgal.org/5.1/Manual/packages.html#PkgSpatialSearchingD)
- The kd-tree can now be built in parallel: [`CGAL::Kd_tree::build()`](https://doc.cgal.org/5.1/Spatial_searching/classCGAL_1_1Kd__tree.html#a8559dbe4d7136fbc8ebab5ee290cbe06)
is given an optional template parameter `ConcurrencyTag` (default is given an optional template parameter `ConcurrencyTag` (default
value remains `CGAL::Sequential_tag` for backward compatibility). value remains [`CGAL::Sequential_tag`](https://doc.cgal.org/5.1/STL_Extension/structCGAL_1_1Sequential__tag.html)
for backward compatibility).
Release 5.0
-----------
Release date: June 2020
### Surface Mesh Topology (new package)
- This package allows to compute some topological invariants of
surfaces:
- test if two (closed) curves on a combinatorial surface are homotopic. The user can choose between free homotopy and homotopy with fixed endpoints.
- test is a curve is contractible.
- compute shortest non-contractible cycles on a surface, with or without weights on edges.
### 3D Fast Intersection and Distance Computation
- **Breaking change**: the internal search tree is now lazily constructed. To disable it, one must call
the new function `do_not_accelerate_distance_queries()` before the first distance query.
### Intersecting Sequences of dD Iso-oriented Boxes
- Added parallel versions of the functions `CGAL::box_intersection_d()` and `CGAL::box_self_intersection_d()`.
### CGAL and the Boost Graph Library (BGL)
- Introduced the function `set_triangulation_ids(Triangulation& tr)` which must be used to initialize vertex,
edge, and face indices of a triangulation meant to be used with BGL algorithms.
- Added function `alpha_expansion_graphcut()` which regularizes a
multi-label partition over a user-defined graph.
- Added function `regularize_face_selection_borders()` which uses
this alpha expansion graphcut to regularize the borders of a
selected faces on a triangle mesh.
### Polygon Mesh Processing
- Introduced a new function, `CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size()`,
which can be used to remove connected components whose area or volume is under a certain threshold.
Area and volume thresholds are either specified by the user or deduced from the bounding box of the mesh.
- Added the function `CGAL::Polygon_mesh_processing::volume_connected_component()` that can be used to
get information about the nesting of the connected components of a given triangle mesh and about
the volumes defined.
- Added a new named parameter for `keep_large_connected_components()` and `remove_connected_components_of_negligible_size`
that can be used to perform a dry run of the operation, meaning that the function will return the number of connected
components that would be removed with the specified threshold, but without actually removing them.
- The function `CGAL::Polygon_mesh_processing::stitch_borders()` now returns the number
of halfedge pairs that were stitched.
- Introduced the new functions `CGAL::Polygon_mesh_processing::merge_reversible_connected_components()`,
`CGAL::Polygon_mesh_processing::duplicate_incompatible_edges_in_polygon_soup()`,
and `CGAL::Polygon_mesh_processing::orient_triangle_soup_with_reference_triangle_mesh()` that can be helpful
when repairing a polygon soup.
- New function to split meshes along a mesh or a plane:
`CGAL::Polygon_mesh_processing::split()`
- New function to split a single mesh containing several connected components into several meshes containing one connected component:
`CGAL::Polygon_mesh_processing::split_connected_components()`
- Added parallel versions of the functions `CGAL::Polygon_mesh_processing::does_self_intersect()`
and `CGAL::Polygon_mesh_processing::self_intersections()`.
- The function `CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh` now allows passing a point map (for the point range)
and a vertex point map (for the polygon mesh) via named parameters.
- Added the function `CGAL::Polygon_mesh_processing::polygon_mesh_to_polygon_soup()`.
- Added a new function `CGAL::Polygon_mesh_processing::sample_triangle_soup()` that generates points on a triangle soup surface.
### Point Set Processing
- Added wrapper functions for registration:
- `CGAL::OpenGR::compute_registration_transformation()` computes the registration transformation
for two point sets using Super4PCS algorithm implemented in the third party library OpenGR.
- `CGAL::OpenGR::register_point_sets()` computes the registration transformation for two point
sets using Super4PCS algorithm implemented in the third party library OpenGR, and registers
the points sets by transforming the data point set using the computed transformation.
- `CGAL::pointmatcher::compute_registration_transformation()` computes the registration
transformation for two point sets using ICP algorithm implemented in the third party library
libpointmatcher.
- `CGAL::pointmatcher::register_point_sets()` computes the registration transformation for two point
sets using ICP algorithm implemented in the third party library libpointmatcher, and registers
the points sets by transforming the data point set using the computed transformation.
### 2D Triangulations
- To fix an inconsistency between code and documentation and to clarify which types of intersections
are truly allowed in constrained Delaunay triangulations, the tag `CGAL::No_intersection_tag`
has been deprecated in favor of two new tags `CGAL::No_constraint_intersection_tag`
and `CGAL::No_constraint_intersection_requiring_constructions_tag`.
The latter is equivalent to the now-deprecated `CGAL::No_intersection_tag`, and allows constraints
to intersect as long as no new point has to be created to represent that intersection (for example,
the intersection of two constraint segments in a 'T'-like junction is an existing point
and does not require any new construction). The former tag, `CGAL::No_constraint_intersection_tag`,
does not allow any intersection, except for the configuration of two constraints having a single
common endpoints, for convience.
### 3D Triangulations
- The free function `CGAL::file_input()` and the member function `CGAL::Triangulation_3::file_input()`
have been added. The first allows to load a `Triangulation_3` from an input stream, using functors to create vertices and cells.
The second is simply the member function version of the first one.
### 3D Triangulation Data Structure
- The free function `CGAL::file_input()` and the member function `CGAL::TDS_3::file_input()`
have been added. The first allows to load a `TDS_3` from an input stream, using functors to create vertices and cells.
The second is simply the member function version of the first one.
### dD Spatial Searching
- Improved the performance of the kd-tree in some cases: - Improved the performance of the kd-tree in some cases:
- Not storing the points coordinates inside the tree usually - Not storing the points coordinates inside the tree usually
generates a lot of cache misses, leading to non-optimal generates a lot of cache misses, leading to non-optimal
performance. This is the case for example performance. This is the case for example
when indices are stored inside the tree, or to a lesser extent when the points when indices are stored inside the tree, or to a lesser extent when the points
coordinates are stored in a dynamically allocated array (e.g., `Epick_d` coordinates are stored in a dynamically allocated array (e.g., [`Epick_d`](https://doc.cgal.org/5.1/Kernel_d/structCGAL_1_1Epick__d.html)
with dynamic dimension) — we says "to a lesser extent" because the points with dynamic dimension) — we says "to a lesser extent" because the points
are re-created by the kd-tree in a cache-friendly order after its construction, are re-created by the kd-tree in a cache-friendly order after its construction,
so the coordinates are more likely to be stored in a near-optimal order so the coordinates are more likely to be stored in a near-optimal order
on the heap. on the heap.
In these cases, the new `EnablePointsCache` template parameter of the In these cases, the new `EnablePointsCache` template parameter of the
`CGAL::Kd_tree` class can be set to `CGAL::Tag_true`. The points coordinates [`CGAL::Kd_tree`](https://doc.cgal.org/5.1/Spatial_searching/classCGAL_1_1Kd__tree.html)
class can be set to `CGAL::Tag_true`. The points coordinates
will then be cached in an optimal way. This will increase memory will then be cached in an optimal way. This will increase memory
consumption but provides better search performance. See the updated consumption but provides better search performance. See the updated
`GeneralDistance` and `FuzzyQueryItem` [`GeneralDistance`](https://doc.cgal.org/5.1/Spatial_searching/classGeneralDistance.html)
and [`FuzzyQueryItem`](https://doc.cgal.org/5.1/Spatial_searching/classFuzzyQueryItem.html)
concepts for additional requirements when using such a cache. concepts for additional requirements when using such a cache.
- In most cases (e.g., Euclidean distance), the distance computation - In most cases (e.g., Euclidean distance), the distance computation
algorithm knows before its end that the distance will be greater algorithm knows before its end that the distance will be greater
@ -155,26 +86,119 @@ Release date: June 2020
k-NN search to interrupt some distance computations before its end, k-NN search to interrupt some distance computations before its end,
saving precious milliseconds, in particular in medium-to-high dimension. saving precious milliseconds, in particular in medium-to-high dimension.
### Spatial Sorting ### [Intersecting Sequences of dD Iso-oriented Boxes](https://doc.cgal.org/5.1/Manual/packages.html#PkgBoxIntersectionD)
- Added parallel versions of `hilbert_sort()` and `spatial_sort()` in 2D and 3D when the median policy is used.
- Added parallel versions of the functions
[`CGAL::box_intersection_d()`](https://doc.cgal.org/5.1/Box_intersection_d/group__PkgBoxIntersectionD__box__intersection__d.html)
and [`CGAL::box_self_intersection_d()`](https://doc.cgal.org/5.1/Box_intersection_d/group__PkgBoxIntersectionD__box__self__intersection__d.html).
### [Spatial Sorting](https://doc.cgal.org/5.1/Manual/packages.html#PkgSpatialSorting)
- Added parallel versions of the functions
[`CGAL::hilbert_sort()`](https://doc.cgal.org/5.1/Spatial_sorting/group__PkgSpatialSortingFunctions.html#ga9da67204747ac19dff65f9c9ff2fca9e)
and [`CGAL::spatial_sort()`](https://doc.cgal.org/5.1/Spatial_sorting/group__PkgSpatialSortingFunctions.html#ga7c597c11a3b3859234ff68526cead84d)
in 2D and 3D when the median policy is used.
The parallel versions use up to four threads in 2D, and up to eight threads in 3D. The parallel versions use up to four threads in 2D, and up to eight threads in 3D.
### dD Geometry Kernel ### [3D Convex Hulls](https://doc.cgal.org/5.1/Manual/packages.html#PkgConvexHull3)
- Epick\_d and Epeck\_d gain 2 new functors: `Power_side_of_bounded_power_sphere_d` and
`Compute_squared_radius_smallest_orthogonal_sphere_d`. Those are
essential for the computation of weighted alpha-complexes.
### Surface Mesh Simplification - A new overload for [`CGAL::convex_hull_3()`](https://doc.cgal.org/5.1/Convex_hull_3/group__PkgConvexHull3Functions.html#gaa02a3013808fc9a2e5e2f42b9fde8e30)
- Added a new simplification method based on the quadric error defined by Garland and Heckbert. that takes a model of `VertexListGraph` has been added.
- The concept "EdgeProfile" has been removed. This concept was not actually in use as the CGAL-provided model `CGAL::Edge_profile` - The long-deprecated function `CGAL::convex_hull_3_to_polyhedron_3()` has been removed.
The function [`CGAL::convex_hull_3_to_face_graph()`](https://doc.cgal.org/5.1/Convex_hull_3/group__PkgConvexHull3Functions.html#ga2750f7f197588ed643679835c748c671)
should be used instead.
### [Polygon Mesh Processing](https://doc.cgal.org/5.1/Manual/packages.html#PkgPolygonMeshProcessing)
- Added the function [`CGAL::Polygon_mesh_processing::volume_connected_component()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__orientation__grp.html#ga133e58280959c152770525f27bb42b91),
which can be used to get information about the nesting of the connected components of a given triangle mesh and about
the volumes defined.
- Added the function [`CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#gac544fcaba1d59d330a3a1536caff392a),
which can be used to remove connected components whose area or volume is under a certain threshold.
Area and volume thresholds are either specified by the user or deduced from the bounding box of the mesh.
- Added a new named parameter for [`CGAL::Polygon_mesh_processing::keep_large_connected_components()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__keep__connected__components__grp.html#ga48e7b3e6922ee78cf8ce801e3e325d9a)
and [`CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#gac544fcaba1d59d330a3a1536caff392a),
which can be used to perform a dry run of the operation, meaning that the function will return the number of connected
components that would be removed with the specified threshold, but without actually removing them.
- Added the function [`CGAL::Polygon_mesh_processing::split()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__corefinement__grp.html#gaa491feee9e41f725332bea0ea1215578),
which can be used to split meshes along a mesh or a plane.
- Added the function [`CGAL::Polygon_mesh_processing::split_connected_components()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__keep__connected__components__grp.html#ga9ddd1e4b915a4232b1ce5611985302aa)
to split a single mesh containing several connected components into several meshes containing one connected component.
- Added the functions [`CGAL::Polygon_mesh_processing::merge_reversible_connected_components()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__orientation__grp.html#gae25c1198a89c53d5df2f29dd57fda5ca),
[`CGAL::Polygon_mesh_processing::duplicate_non_manifold_edges_in_polygon_soup()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__orientation__grp.html#ga2aa4f7b500dc51d1fc4747705a050946),
and [`CGAL::Polygon_mesh_processing::orient_triangle_soup_with_reference_triangle_mesh()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__orientation__grp.html#ga31779672b3afd660664fc9a6c4fdf74d),
which can be helpful when repairing a polygon soup.
- Added the function [`CGAL::Polygon_mesh_processing::sample_triangle_soup()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__distance__grp.html#gac7af41d13bf1a7c30852be266ac81db5),
which generates points on a triangle soup surface.
- Added parallel versions of the functions [`CGAL::Polygon_mesh_processing::does_self_intersect()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__intersection__grp.html#gad9fe5d8b433545b69154f43935a11a3b)
and [`CGAL::Polygon_mesh_processing::self_intersections()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__intersection__grp.html#gaf19c80ec12cbff7ebe9e69453f1d40b8).
- The function [`CGAL::Polygon_mesh_processing::stitch_borders()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#ga8ae4352e67d2b099994ac8990c13bd41)
now returns the number of halfedge pairs that were stitched.
- Added the function [`CGAL::Polygon_mesh_processing::polygon_mesh_to_polygon_soup()`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#ga76648a509409ff3c3ad3f71eff8ce9d9).
- The function [`CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh`](https://doc.cgal.org/5.1/Polygon_mesh_processing/group__PMP__repairing__grp.html#ga0dec58e8a0112791f72ebbe77bac074b)
now allows passing a point map (for the point range) and a vertex point map (for the polygon mesh) via named parameters.
### [Point Set Processing](https://doc.cgal.org/5.1/Manual/packages.html#PkgPointSetProcessing3)
- Added wrapper functions for registration:
- [`CGAL::OpenGR::compute_registration_transformation()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#gab81663c718960780ddb176aad845e8cd),
which computes the registration transformation for two point sets using the Super4PCS algorithm
implemented in the third party library [OpenGR](https://storm-irit.github.io/OpenGR/index.html).
- [`CGAL::OpenGR::register_point_sets()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga6194087f512e4e23dd945a9364d0931d),
which computes the registration transformation for two point sets using the Super4PCS algorithm
implemented in the third party library [OpenGR](https://storm-irit.github.io/OpenGR/index.html),
and registers the points sets by transforming the data point set using the computed transformation.
- [`CGAL::pointmatcher::compute_registration_transformation()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#gaf75af5c1634fa83fa05a33e95570b127)
computes the registration transformation for two point sets using ICP algorithm implemented
in the third party library [libpointmatcher](https://github.com/ethz-asl/libpointmatcher).
- [`CGAL::pointmatcher::register_point_sets()`](https://doc.cgal.org/5.1/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#gaa222278e20a3ce41930d37326cd54ef9),
which computes the registration transformation for two point sets using ICP algorithm implemented
in the third party library [libpointmatcher](https://github.com/ethz-asl/libpointmatcher), and registers
the points sets by transforming the data point set using the computed transformation.
### [2D Triangulations](https://doc.cgal.org/5.1/Manual/packages.html#PkgTriangulation2)
- To fix an inconsistency between code and documentation and to clarify which types of intersections
are truly allowed in constrained Delaunay triangulations, the tag [`CGAL::No_intersection_tag`](https://doc.cgal.org/5.1/Triangulation_2/structCGAL_1_1No__intersection__tag.html)
has been deprecated in favor of two new tags: [`CGAL::No_constraint_intersection_tag`](https://doc.cgal.org/5.1/Triangulation_2/structCGAL_1_1No__constraint__intersection__tag.html)
and [`CGAL::No_constraint_intersection_requiring_constructions_tag`](https://doc.cgal.org/5.1/Triangulation_2/structCGAL_1_1No__constraint__intersection__requiring__constructions__tag.html).
The latter is equivalent to the now-deprecated `CGAL::No_intersection_tag`, and allows constraints
to intersect as long as no new point has to be created to represent that intersection (for example,
the intersection of two constraint segments in a 'T'-like junction is an existing point
and as such does not require any new construction). The former tag, `CGAL::No_constraint_intersection_tag`,
does not allow any intersection, except for the configuration of two constraints having a single
common endpoints, for convience.
- Added the function [`CGAL::split_subconstraint_graph_into_constraints()`](https://doc.cgal.org/5.1/Triangulation_2/classCGAL_1_1Constrained__triangulation__plus__2.html#adea77f5db5cd4dfae302e4502f1caa85)
to [`Constrained_triangulation_plus_2`](https://doc.cgal.org/5.1/Triangulation_2/classCGAL_1_1Constrained__triangulation__plus__2.html) to initialize the constraints
from a soup of disconnected segments that should first be split into polylines.
### [3D Triangulations](https://doc.cgal.org/5.1/Manual/packages.html#PkgTriangulation3)
- The free function `CGAL::file_input()` and the member function [`CGAL::Triangulation_3::file_input()`](https://doc.cgal.org/5.1/Triangulation_3/group__PkgIOTriangulation3.html#gadd94d0613e2dd9cdd2e88d2c74d5b1c8)
have been added. The first allows to load a [`CGAL::Triangulation_3`](https://doc.cgal.org/5.1/Triangulation_3/classCGAL_1_1Triangulation__3.html)
from an input stream, using functors to create vertices and cells.
The second is simply the member function version of the first one.
### [3D Triangulation Data Structure](https://doc.cgal.org/5.1/Manual/packages.html#PkgTDS3)
- The free function `CGAL::file_input()` and the member function [`CGAL::TDS_3::file_input()`](https://doc.cgal.org/5.1/TDS_3/group__PkgIOTDS3.html#ga381446a02a9240cc83e79c48b37cd119)
have been added. The first allows to load a [`CGAL::Triangulation_data_structure_3`](https://doc.cgal.org/5.1/TDS_3/classCGAL_1_1Triangulation__data__structure__3.html)
from an input stream, using functors to create vertices and cells.
The second is simply the member function version of the first one.
### [Surface Mesh Simplification](https://doc.cgal.org/5.1/Manual/packages.html#PkgSurfaceMeshSimplification)
- Added a [new simplification method](https://doc.cgal.org/5.1/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1GarlandHeckbert__policies.html)
based on the quadric error defined by Garland and Heckbert.
- The concept `EdgeProfile` has been removed. This concept was not actually in use as the CGAL-provided model [`CGAL::Edge_profile`](https://doc.cgal.org/5.1/Surface_mesh_simplification/classCGAL_1_1Surface__mesh__simplification_1_1Edge__profile.html)
was imposed to the user. Other concepts have been clarified to reflect the fact that the API uses this particular class. was imposed to the user. Other concepts have been clarified to reflect the fact that the API uses this particular class.
### STL Extensions for CGAL ### [STL Extensions for CGAL](https://doc.cgal.org/5.1/Manual/packages.html#PkgSTLExtension)
- Added a new concurrency tag: `CGAL::Parallel_if_available_tag`. This tag is a convenience typedef to `CGAL::Parallel_tag`
if the third party library TBB has been found and linked with, and to `CGAL::Sequential_tag` otherwise.
### Convex_hull_3 - Added a new concurrency tag: [`CGAL::Parallel_if_available_tag`](https://doc.cgal.org/5.1/STL_Extension/structCGAL_1_1Parallel__if__available__tag.html).
- A new overload for `convex_hull_3()` that takes a model of `VertexListGraph` has been added. This tag is a convenience typedef to [`CGAL::Parallel_tag`](https://doc.cgal.org/5.1/STL_Extension/structCGAL_1_1Parallel__tag.html)
if the third party library TBB has been found and linked with, and to
[`CGAL::Sequential_tag`](https://doc.cgal.org/5.1/STL_Extension/structCGAL_1_1Sequential__tag.html) otherwise.
[Release 5.0](https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.0) [Release 5.0](https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.0)