From 0f63849a434ac3921fba56ba1bd709d4a6887d7c Mon Sep 17 00:00:00 2001 From: Laurent Rineau Date: Wed, 10 Jun 2020 10:08:48 +0200 Subject: [PATCH] First draft for the announcement mail --- Installation/CHANGES.md | 42 +-- .../announcement/mailing-beta.eml | 353 ++++++++++++++---- 2 files changed, 293 insertions(+), 102 deletions(-) diff --git a/Installation/CHANGES.md b/Installation/CHANGES.md index 0352def2515..14bfe13c5af 100644 --- a/Installation/CHANGES.md +++ b/Installation/CHANGES.md @@ -28,7 +28,7 @@ Release date: July 2020 - This package implements a tetrahedral isotropic remeshing algorithm, that improves the quality of tetrahedra in terms of dihedral angles, - while targetting a given edge length. + while targeting a given edge length. ### [Tutorials](https://doc.cgal.org/5.1/Manual/tutorials.html) @@ -273,13 +273,13 @@ Release date: November 2019 ### [Polygonal Surface Reconstruction](https://doc.cgal.org/5.0/Manual/packages.html#PkgPolygonalSurfaceReconstruction) (new package) - - This package provides a method for piecewise planar object reconstruction from point clouds. - The method takes as input an unordered point set sampled from a piecewise planar object - and outputs a compact and watertight surface mesh interpolating the input point set. - The method assumes that all necessary major planes are provided (or can be extracted from - the input point set using the shape detection method described in Point Set Shape Detection, - or any other alternative methods).The method can handle arbitrary piecewise planar objects - and is capable of recovering sharp features and is robust to noise and outliers. See also + - This package provides a method for piecewise planar object reconstruction from point clouds. + The method takes as input an unordered point set sampled from a piecewise planar object + and outputs a compact and watertight surface mesh interpolating the input point set. + The method assumes that all necessary major planes are provided (or can be extracted from + the input point set using the shape detection method described in Point Set Shape Detection, + or any other alternative methods).The method can handle arbitrary piecewise planar objects + and is capable of recovering sharp features and is robust to noise and outliers. See also the associated [blog entry](https://www.cgal.org/2019/08/05/Polygonal_surface_reconstruction/). ### [Shape Detection](https://doc.cgal.org/5.0/Manual/packages.html#PkgShapeDetection) (major changes) @@ -294,11 +294,11 @@ Release date: November 2019 ### [2D and 3D Linear Geometry Kernel](https://doc.cgal.org/5.0/Manual/packages.html#PkgKernel23) - Added a new concept, [`ComputeApproximateAngle_3`](https://doc.cgal.org/5.0/Kernel_23/classKernel_1_1ComputeApproximateAngle__3.html), to the 3D Kernel concepts to compute the approximate angle between two 3D vectors. Corresponding functors - in the model ([`Compute_approximate_angle_3`](https://doc.cgal.org/5.0/Kernel_23/classKernel.html#a183c9ac358a4ccddc04e680f8ed16c0b)) + in the model ([`Compute_approximate_angle_3`](https://doc.cgal.org/5.0/Kernel_23/classKernel.html#a183c9ac358a4ccddc04e680f8ed16c0b)) and free function ([`approximate_angle`](https://doc.cgal.org/5.0/Kernel_23/group__approximate__angle__grp.html)) have also been added. - - The following objects are now hashable and thus trivially usable - with [`std::unordered_set`](https://en.cppreference.com/w/cpp/container/unordered_set) + - The following objects are now hashable and thus trivially usable + with [`std::unordered_set`](https://en.cppreference.com/w/cpp/container/unordered_set) and [`std::unordered_map`](https://en.cppreference.com/w/cpp/header/unordered_map): `CGAL::Aff_transformation_2`, `CGAL::Aff_transformation_3`, `CGAL::Bbox_2`, `CGAL::Bbox_3`, `CGAL::Circle_2`, @@ -308,11 +308,11 @@ Release date: November 2019 `CGAL::Weighted_point_2` and `CGAL::Weighted_point_3`. ### [Polygon Mesh Processing](https://doc.cgal.org/latest/Manual/packages.html#PkgPolygonMeshProcessing) - - Introduced a [wide range of new functions](https://doc.cgal.org/5.0/Polygon_mesh_processing/index.html#title36) + - Introduced a [wide range of new functions](https://doc.cgal.org/5.0/Polygon_mesh_processing/index.html#title36) related to location of queries on a triangle mesh, such as [`CGAL::Polygon_mesh_processing::locate(Point, Mesh)`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__PMP__locate__grp.html#gada09bd8740ba69ead9deca597d53cf15). The location of a point on a triangle mesh is expressed as the pair of a face and the barycentric - coordinates of the point in this face, enabling robust manipulation of locations + coordinates of the point in this face, enabling robust manipulation of locations (for example, intersections of two 3D segments living within the same face). - Added the mesh smoothing function [`smooth_mesh()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__PMP__meshing__grp.html#gaa0551d546f6ab2cd9402bea12d8332a3), which can be used to improve the quality of triangle elements based on various geometric characteristics. @@ -335,14 +335,14 @@ Release date: November 2019 or vertices appearing in multiple umbrellas) of a mesh. ### [3D Point Set](https://doc.cgal.org/5.0/Manual/packages.html#PkgPointSet3) - - The [PLY IO functions](https://doc.cgal.org/5.0/Point_set_3/group__PkgPointSet3IO.html) now take an additional optional parameter to + - The [PLY IO functions](https://doc.cgal.org/5.0/Point_set_3/group__PkgPointSet3IO.html) now take an additional optional parameter to read/write comments from/in the PLY header. ### [Point Set Processing](https://doc.cgal.org/latest/Manual/packages.html#PkgPointSetProcessing3) - **Breaking change**: the API using iterators and overloads for optional parameters (deprecated since CGAL 4.12) has been removed. The current (and now only) API uses ranges and Named Parameters. - Added the possibility to use the named parameter - [`neighbor_radius`](https://doc.cgal.org/5.0/Point_set_processing_3/group__psp__namedparameters.html#PSP_neighbor_radius) + [`neighbor_radius`](https://doc.cgal.org/5.0/Point_set_processing_3/group__psp__namedparameters.html#PSP_neighbor_radius) to use spherical neighbor queries instead of K-nearest neighbors queries for the following functions: [`CGAL::bilateral_smooth_point_set()`](https://doc.cgal.org/5.0/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga4f82723e2f0bb33f3677e29e0208a256), [`CGAL::jet_estimate_normals()`](https://doc.cgal.org/5.0/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga0cd0f87de690d4edf82740e856efa491), @@ -385,7 +385,7 @@ Release date: November 2019 ### [3D Triangulations](https://doc.cgal.org/5.0/Manual/packages.html#PkgTriangulation3) - **Breaking change**: The [constructor](https://doc.cgal.org/5.0/Triangulation_3/classCGAL_1_1Triangulation__3.html#a63f67cf6aaadcee14318cf56a36d247a) and the [`insert()`](https://doc.cgal.org/5.0/Triangulation_3/classCGAL_1_1Triangulation__3.html#ad3353128386bbb51f79d0263e7f67337) - function of [`CGAL::Triangulation_3`](https://doc.cgal.org/5.0/Triangulation_3/classCGAL_1_1Triangulation__3.html) + function of [`CGAL::Triangulation_3`](https://doc.cgal.org/5.0/Triangulation_3/classCGAL_1_1Triangulation__3.html) which take a range of points as argument are now guaranteed to insert the points following the order of `InputIterator`. Note that this change only affects the base class `Triangulation_3` @@ -397,14 +397,14 @@ Release date: November 2019 ### [Surface Mesh](https://doc.cgal.org/5.0/Manual/packages.html#PkgSurfaceMesh) - Introduced new functions to read and write using the PLY format, - [`CGAL::read_ply()`](https://doc.cgal.org/5.0/Surface_mesh/group__PkgSurface__mesh.html#ga42f6ad486ddab74e13d3dc53f511c343) - and [`CGAL::write_ply()`](https://doc.cgal.org/5.0/Surface_mesh/group__PkgSurface__mesh.html#ga77bbb79d449c981895eedb6c3c23bd14), + [`CGAL::read_ply()`](https://doc.cgal.org/5.0/Surface_mesh/group__PkgSurface__mesh.html#ga42f6ad486ddab74e13d3dc53f511c343) + and [`CGAL::write_ply()`](https://doc.cgal.org/5.0/Surface_mesh/group__PkgSurface__mesh.html#ga77bbb79d449c981895eedb6c3c23bd14), enabling users to save and load additional property maps of the surface mesh. ### [CGAL and Solvers](https://doc.cgal.org/5.0/Manual/packages.html#PkgSolverInterface) - Added [concepts](https://doc.cgal.org/5.0/Solver_interface/group__PkgSolverInterfaceConcepts.html) - and [models](https://doc.cgal.org/5.0/Solver_interface/group__PkgSolverInterfaceRef.html) - for solving Mixed Integer Programming (MIP) problems with or without constraints. + and [models](https://doc.cgal.org/5.0/Solver_interface/group__PkgSolverInterfaceRef.html) + for solving Mixed Integer Programming (MIP) problems with or without constraints. ### [3D Boolean Operations on Nef Polyhedra](https://doc.cgal.org/5.0/Manual/packages.html#PkgNef3) - Added a function to convert a Nef_polyhedron_3 to a polygon soup: [`CGAL::convert_nef_polyhedron_to_polygon_soup()`](https://doc.cgal.org/5.0/Nef_3/group__PkgNef3IOFunctions.html#ga28a9eb4da0cd6153f0c16f7f9eaf6665) @@ -433,7 +433,7 @@ Release 4.14 Release date: March 2019 ### 2D Periodic Hyperbolic Triangulations (new package) - + - This package allows the computation of Delaunay triangulations of the Bolza surface. The Bolza surface is the most symmetric hyperbolic surface of genus 2. Its fundamental domain is the diff --git a/Maintenance/public_release/announcement/mailing-beta.eml b/Maintenance/public_release/announcement/mailing-beta.eml index 11251b7563a..999c8503444 100644 --- a/Maintenance/public_release/announcement/mailing-beta.eml +++ b/Maintenance/public_release/announcement/mailing-beta.eml @@ -1,111 +1,302 @@ -Subject: CGAL 5.0 Beta 2 Released, Computational Geometry Algorithms Library +Subject: CGAL 5.1 Beta 1 Released, Computational Geometry Algorithms Library Content-Type: text/plain; charset="utf-8" -Body: +Body: -The CGAL Open Source Project is pleased to announce the release 5.0 Beta 2 +The CGAL Open Source Project is pleased to announce the release 5.1 Beta 1 of CGAL, the Computational Geometry Algorithms Library. -CGAL version 5.0 Beta 2 is a public testing release. It should provide a +CGAL version 5.1 Beta 1 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.0 in November. - -The important changes since CGAL 5.0 Beta 1 are the fix of CMake -issues, with header-only installations, and the update of the section -“Getting Started with CGAL” of the documentation. +of the final version of CGAL 5.1 in July. Besides fixes and general enhancement to existing packages, the following -has changed since CGAL 4.14: - -General changes - -- CGAL 5.0 is the first release of CGAL that requires a C++ compiler - with the support of C++14 or later. The new list of supported - compilers is: - - Visual C++ 14.0 (from Visual Studio 2015 Update 3) or later, - - Gnu g++ 6.3 or later (on Linux or MacOS), - - LLVM Clang version 8.0 or later (on Linux or MacOS), and - - Apple Clang compiler versions 7.0.2 and 10.0.1 (on MacOS). -- Since CGAL 4.9, CGAL can be used as a header-only library, with - dependencies. Since CGAL 5.0, that is now the default, unless - specified differently in the (optional) CMake configuration. -- The section “Getting Started with CGAL” of the documentation has - been updated and reorganized. -- The minimal version of Boost is now 1.57.0. - -Polygonal Surface Reconstruction (new package) - -- This package provides a method for piecewise planar object - reconstruction from point clouds. The method takes as input an - unordered point set sampled from a piecewise planar object and - outputs a compact and watertight surface mesh interpolating the - input point set. The method assumes that all necessary major planes - are provided (or can be extracted from the input point set using the - shape detection method described in Point Set Shape Detection, or - any other alternative methods).The method can handle arbitrary - piecewise planar objects and is capable of recovering sharp features - and is robust to noise and outliers. See also the associated blog - entry: - - https://www.cgal.org/2019/08/05/Polygonal_surface_reconstruction/ +has changed since CGAL 5.0: -Shape Detection (major changes) +Surface Mesh Topology (new package) -- BREAKING CHANGE: The concept ShapeDetectionTraits has been renamed - to EfficientRANSACTraits. -- BREAKING CHANGE: The Shape_detection_3 namespace has been renamed to - Shape_detection. -- Added a new, generic implementation of region growing. This enables - for example applying region growing to inputs such as 2D and 3D - point sets, or models of the FaceGraph concept. Learn more about - this new algorithm with this blog entry: - - https://www.cgal.org/2019/07/30/Shape_detection/ +- This package enables the computation of some topological invariants + of surfaces, such as: + - test if two (closed) curves on a combinatorial surface are + homotopic. Users 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. + See also the associated blog entry: + https://www.cgal.org/2020/05/08/Surface_mesh_topology/ + +Optimal Bounding Box (new package) + +- 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 (in terms of + volume) bounding box that contains a given mesh or point set. + + See also the associated blog entry: + https://www.cgal.org/2020/04/20/Optimal_bounding_box/ + +Tetrahedral Remeshing (new package) + +- This package implements a tetrahedral isotropic remeshing algorithm, + that improves the quality of tetrahedra in terms of dihedral angles, + while targeting a given edge length. + +Tutorials + +- Two new, detailed tutorials have been added: + - Surface Reconstruction from Point Clouds, which goes over a + typical full processing pipeline in a CGAL environment. + - Geographic Information Systems (GIS), which demonstrates usage + of CGAL data structures and algorithms in the context of a + typical GIS application. + + In both tutorials, complete code is provided. + + See https://doc.cgal.org/5.1/Manual/tutorials.html + +2D and 3D Linear Geometry Kernel + +- Added the functor CompareSignedDistanceToLine_2 to the 2D/3D Kernel + concept to compare 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. dD Geometry Kernel -- A new exact kernel, Epeck_d, is now available. +- The kernels Epick_d and Epeck_d gain two 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 -2D and 3D Triangulations +- BREAKING CHANGE: The function CGAL::Surface_mesh::clear() now + removes all non-default properties instead of just emptying them. -- BREAKING CHANGE: Several deprecated functions and classes have been - removed. See the full list of breaking changes in the release notes. +CGAL and the Boost Graph Library (BGL) -- BREAKING CHANGE: The constructor and the insert() function of - CGAL::Triangulation_2 or CGAL::Triangulation_3 which take a range of - points as argument are now guaranteed to insert the points following - the order of InputIterator. Note that this change only affects the - base class CGAL::Triangulation_[23] and not any derived class, such - as CGAL::Delaunay_triangulation_[23]. +- Added the function CGAL::alpha_expansion_graphcut(), which + regularizes a multi-label partition over a user-defined graph. +- Added the function CGAL::regularize_face_selection_borders(), which + uses this alpha expansion graphcut to regularize the borders of a + selected faces on a triangle mesh. +- Added the function CGAL::set_triangulation_ids(), 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 + +- 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 + CGAL::AABB_tree::do_not_accelerate_distance_queries() before the + first distance query, and the tree can be built at any moment by + calling CGAL::AABB_tree::accelerate_distance_queries(). +- BREAKING CHANGE: CGAL::AABB_tree::accelerate_distance_queries() and + CGAL::AABB_tree::do_not_accelerate_distance_queries() are no longer + const functions. + +2D Arrangements + +- Changed intersection return type from legacy CGAL::Object to modern + boost::variant in all traits concepts and models. As there exists an + implicit conversion from boost::variant to CGAL::Object, the new + code is backward compatible. However, it is recommended that all + calls to the intersection functions are fixed to use the new return + type. + +2D Regularized Boolean Set-Operations + +- Changed intersection return type from legacy CGAL::Object to modern + boost::variant in the concept ArrDirectionalTraits::Intersect_2 and + its models. + +2D Minkowski Sums + +- Changed intersection return type from legacy CGAL::Object to modern + boost::variant in the (internally used) model Arr_labeled_traits_2. + +dD Spatial Searching + +- The kd-tree can now be built in parallel: CGAL::Kd_tree::build() is + given an optional template parameter ConcurrencyTag (default value + remains CGAL::Sequential_tag for backward compatibility). +- Improved the performance of the kd-tree in some cases: + - Not storing the points coordinates inside the tree usually + generates a lot of cache misses, leading to non-optimal + performance. This is the case for example 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 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, so the coordinates + are more likely to be stored in a near-optimal order on the + heap. In these cases, the new EnablePointsCache template + parameter of the CGAL::Kd_tree class can be set to + CGAL::Tag_true. The points coordinates will then be cached in an + optimal way. This will increase memory consumption but provides + better search performance. See the updated GeneralDistance and + FuzzyQueryItem concepts for additional requirements when using + such a cache. + - In most cases (e.g., Euclidean distance), the distance + computation algorithm knows before its end that the distance + will be greater than or equal to some given value. This is used + in the (orthogonal) k-NN search to interrupt some distance + computations before its end, saving precious milliseconds, in + particular in medium-to-high dimension. + +Intersecting Sequences of dD Iso-oriented Boxes + +- Added parallel versions of the functions CGAL::box_intersection_d() + and CGAL::box_self_intersection_d(). + +Spatial Sorting + +- Added parallel versions of the functions CGAL::hilbert_sort() and + CGAL::spatial_sort() 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. + +3D Convex Hulls + +- A new overload for CGAL::convex_hull_3() that takes a model of + VertexListGraph has been added. +- The long-deprecated function CGAL::convex_hull_3_to_polyhedron_3() + has been removed. The function CGAL::convex_hull_3_to_face_graph() + should be used instead. Polygon Mesh Processing -- Introduced a wide range of new functions related to location of - queries on a triangle mesh, such as - CGAL::Polygon_mesh_processing::locate(Point, Mesh). The location of - a point on a triangle mesh is expressed as the pair of a face and - the barycentric coordinates of the point in this face, enabling - robust manipulation of locations (for example, intersections of two - 3D segments living within the same face). -- Added the mesh smoothing function smooth_mesh(), which can be used - to improve the quality of triangle elements based on various - geometric characteristics. -- Added the shape smoothing function smooth_shape(), which can be used - to smooth the surface of a triangle mesh, using the mean curvature - flow to perform noise removal. - +- Added the function + CGAL::Polygon_mesh_processing::volume_connected_component(), 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(), + 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() and + CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size, + 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(), which can + be used to split meshes along a mesh or a plane. +- Added the function + CGAL::Polygon_mesh_processing::split_connected_components() 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(), + CGAL::Polygon_mesh_processing::duplicate_non_manifold_edges_in_polygon_soup(), + and + CGAL::Polygon_mesh_processing::orient_triangle_soup_with_reference_triangle_mesh(), + which can be helpful when repairing a polygon soup. +- Added the function + CGAL::Polygon_mesh_processing::sample_triangle_soup(), which + generates points on a triangle soup surface. +- 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::stitch_borders() now + returns the number of halfedge pairs that were stitched. +- Added the function + CGAL::Polygon_mesh_processing::polygon_mesh_to_polygon_soup(). +- 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. Point Set Processing -- BREAKING CHANGE: the API using iterators and overloads for optional - parameters (deprecated since CGAL 4.12) has been removed. The - current (and now only) API uses ranges and Named Parameters. +- BREAKING CHANGE: CGAL::remove_outliers() has been parallelized and + thus has a new template parameter ConcurrencyTag. To update your + code simply add as first template parameter CGAL::Sequential_tag or + CGAL::Parallel_tag when calling this function. +- Add a function CGAL::cluster_point_set() that segments a point cloud + into connected components based on a distance threshold. +- Added wrapper functions for registration: + - CGAL::OpenGR::compute_registration_transformation(), which + computes the registration transformation for two point sets + using the Super4PCS algorithm implemented in the third party + library OpenGR. + - CGAL::OpenGR::register_point_sets(), which computes the + registration transformation for two point sets using the + 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(), which 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. -See https://www.cgal.org/2019/10/31/cgal50-beta2/ for a complete list of +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 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() to + Constrained_triangulation_plus_2 to initialize the constraints from + a soup of disconnected segments that should first be split into + polylines. + +3D Triangulations + +- The member function CGAL::Triangulation_3::file_input() have been + added. It allows to load a CGAL::Triangulation_3 from an input + stream, using functors to create vertices and cells. + +3D Triangulation Data Structure + +- The member function CGAL::TDS_3::file_input() have been added. It + allows to load a CGAL::Triangulation_data_structure_3 from an input + stream, using functors to create vertices and cells. + +Surface Mesh Simplification + +- Added a new simplification method 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 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 + +- 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. + +See https://www.cgal.org/2020/06/09/cgal51-beta1/ for a complete list of changes.