From e3cadd8be524dd953a3006b77e53d0111d68121a Mon Sep 17 00:00:00 2001 From: Laurent Rineau Date: Mon, 30 Sep 2019 09:45:20 +0200 Subject: [PATCH 1/5] Reformat CHANGES.md --- Installation/CHANGES.md | 250 +++++++++++++++++++++++++--------------- 1 file changed, 158 insertions(+), 92 deletions(-) diff --git a/Installation/CHANGES.md b/Installation/CHANGES.md index b0d3bf739411..4e711a73a713 100644 --- a/Installation/CHANGES.md +++ b/Installation/CHANGES.md @@ -8,123 +8,188 @@ Release date: September 2019 ### 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. +- 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. ### Solver Interface - - Added concepts and models for solving Mixed Integer Programming (MIP) problems with or without constraints. + - Added concepts and models for solving Mixed Integer Programming + (MIP) problems with or without constraints. -## 2D Triangulations +### dD Geometry Kernel + +- New exact kernel `Epeck_d` + +### 2D and 3D Linear Geometry Kernel + +- Add `ComputeApproximateAngle_3` in the 2D/3D Kernel concept to + compute the approximate dihedral angle between 2 + vectors. Corresponding functors in the model + (`Compute_approximate_angle_3`) and free function + (`approximate_angle`) are also added. + +- The following objects are now hashable and thus trivially usable + with `std::unordered_set` and `std::unordered_map`: + `CGAL::Aff_transformation_2`, `CGAL::Aff_transformation_3`, + `CGAL::Bbox_2`, `CGAL::Bbox_3`, `CGAL::Circle_2`, + `CGAL::Iso_cuboid_3`, `CGAL::Iso_rectangle_2`, `CGAL::Point_2`, + `CGAL::Point_3`, `CGAL::Segment_2`, `CGAL::Segment_3`, + `CGAL::Sphere_3`, `CGAL::Vector_2`, `CGAL::Vector_3`, + `CGAL::Weighted_point_2` and `CGAL::Weighted_point_3`. + +### 3D Boolean Operations on Nef Polyhedra + +- Added a function to convert a Nef_polyhedron_3 to a polygon soup: + `CGAL::convert_nef_polyhedron_to_polygon_soup()` + +### 2D Triangulations + - Added range types and functions that return ranges, for example for all vertices, which enables to use C++11 for-loops. -- **Breaking change**: Removed the functions `CGAL::Constrained_triangulation_plus_2:: - vertices_in_constraint_{begin/end}(Vertex_handle va, Vertex_handle vb) const;`, - and `CGAL::Constrained_triangulation_plus_2::remove_constraint((Vertex_handle va, Vertex_handle vb)`, - that is a pair of vertex handles is no longer a key for a polyline constraint. - Users must use a version prior to 5.0 if they need this functionality. -- **Breaking change**: Removed the deprecated classes `CGAL::Regular_triangulation_euclidean_traits_2`, `CGAL::Regular_triangulation_filtered_traits_2`. Users must use a version prior to 5.0 if they need these classes. -- **Breaking change**: The constructor and the `insert()` function of `CGAL::Triangulation_2` which takes - a range of points as argument no longer performs a `spatial_sort()` of the points. -- Add constructor and `insert()` function to `CGAL::Triangulation_2` that takes a range of points with info. - - **Breaking change**: The graph traits enabling CGAL's 2D triangulations to be used as a parameter - for any graph-based algorithm of CGAL (or boost) have been improved to fully model the `FaceGraph` concept. - In addition, only the finite simplicies (those not incident to the infinite vertex) of the 2D triangulations - are now visibile through this scope. The complete triangulation can still be accessed as a graph, - by using the graph traits of the underlying triangulation data structure (usually, + +- **Breaking change**: Removed the functions + `CGAL::Constrained_triangulation_plus_2:: + vertices_in_constraint_{begin/end}(Vertex_handle va, Vertex_handle + vb) const;`, and + `CGAL::Constrained_triangulation_plus_2::remove_constraint((Vertex_handle + va, Vertex_handle vb)`, that is a pair of vertex handles is no + longer a key for a polyline constraint. Users must use a version + prior to 5.0 if they need this functionality. + +- **Breaking change**: Removed the deprecated classes + `CGAL::Regular_triangulation_euclidean_traits_2`, + `CGAL::Regular_triangulation_filtered_traits_2`. Users must use + a version prior to 5.0 if they need these classes. + +- **Breaking change**: The constructor and the `insert()` function + of `CGAL::Triangulation_2` which takes a range of points as + argument no longer performs a `spatial_sort()` of the points. + +- Add constructor and `insert()` function to `CGAL::Triangulation_2` + that takes a range of points with info. + +- **Breaking change**: The graph traits enabling CGAL's 2D + triangulations to be used as a parameter for any graph-based + algorithm of CGAL (or boost) have been improved to fully model the + `FaceGraph` concept. In addition, only the finite simplicies + (those not incident to the infinite vertex) of the 2D + triangulations are now visibile through this scope. The complete + triangulation can still be accessed as a graph, by using the graph + traits of the underlying triangulation data structure (usually, `CGAL::Triangulation_data_structure_2`). - - Introduced a new face base class, `Triangulation_face_base_with_id_2` which enables storing - user-defined integer IDs in the face of any 2D triangulation, a precondition to use some - BGL algorithms. + +- Introduced a new face base class, + `Triangulation_face_base_with_id_2` which enables storing + user-defined integer IDs in the face of any 2D triangulation, a + precondition to use some BGL algorithms. + + ### 3D Triangulations + - Added range types and functions that return ranges, for example for all vertices, which enables to use C++11 for-loops. -- **Breaking change**: The constructor and the `insert()` function of `CGAL::Triangulation_3` which takes - a range of points as argument no longer performs a `spatial_sort()` of the points. -- Add constructor and `insert()` function to `CGAL::Triangulation_3` that takes a range of points with info. + +- **Breaking change**: The constructor and the `insert()` function + of `CGAL::Triangulation_3` which takes a range of points as + argument no longer performs a `spatial_sort()` of the points. + +- Add constructor and `insert()` function to `CGAL::Triangulation_3` + that takes a range of points with info. ### Surface Mesh - - New functions to read and write using the PLY format, - `CGAL::read_ply()` and `CGAL::write_ply()`, allowing to save and - load additional property maps of the surface mesh. + +- New functions to read and write using the PLY format, + `CGAL::read_ply()` and `CGAL::write_ply()`, allowing to save and + load additional property maps of the surface mesh. + +### Polygon Mesh Processing + +- Added the function + `CGAL::Polygon_mesh_processing::non_manifold_vertices()`, which + can be used to collect all the non-manifold vertices (i.e. pinched + vertices, or vertices appearing in multiple umbrellas) of a mesh. + +- 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 function `CGAL::Polygon_mesh_processing::centroid()`, + which computes the centroid of a closed triangle mesh. + +- Added the functions + `CGAL::Polygon_mesh_processing::stitch_boundary_cycle()` and + `CGAL::Polygon_mesh_processing::stitch_boundary_cycles()`, which + can be used to try and merge together geometrically compatible but + combinatorially different halfedges that belong to the same + boundary cycle. + +- It is now possible to pass a face-size property map to + `CGAL::Polygon_mesh_processing::keep_large_connected_components()` + and + `CGAL::Polygon_mesh_processing::keep_largest_connected_components()`, + enabling users to define how the size of a face is computed (the + size of the connected component is the sum of the sizes of its + faces). If no property map is passed, the behavior is unchanged + to previous versions: the size of a connected component is the + number of faces it contains. + +- 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. ### 3D Point Set - - The PLY IO functions now take an additional optional parameter to - read/write comments from/in the PLY header. + +- The PLY IO functions now take an additional optional parameter to + read/write comments from/in the PLY header. ### Point Set Processing - - **Breaking change**: the old API using iterators and overloads - for optional parameters is now removed (it was deprecated since - CGAL 4.12). The current (and now only) API uses ranges and Named - Parameters. - - Added the possibility to use the named parameter - `neighbor_radius` to use spherical neighbor queries instead of - K-nearest neighbors queries for the following functions: - `CGAL::bilateral_smooth_point_set()`, - `CGAL::jet_estimate_normals()`, `CGAL::jet_smooth_point_set()`, - `CGAL::mst_orient_normals()`, `CGAL::pca_estimate_normals()` and - `CGAL::remove_outliers()`. -### Polygon Mesh Processing -- Added the function `CGAL::Polygon_mesh_processing::non_manifold_vertices()`, - which can be used to collect all the non-manifold vertices (i.e. pinched vertices, - or vertices appearing in multiple umbrellas) of a mesh. - - 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 function `CGAL::Polygon_mesh_processing::centroid()`, which computes - the centroid of a closed triangle mesh. - - Added the functions `CGAL::Polygon_mesh_processing::stitch_boundary_cycle()` and - `CGAL::Polygon_mesh_processing::stitch_boundary_cycles()`, which can be used - to try and merge together geometrically compatible but combinatorially different halfedges - that belong to the same boundary cycle. -- It is now possible to pass a face-size property map to `CGAL::Polygon_mesh_processing::keep_large_connected_components()` - and `CGAL::Polygon_mesh_processing::keep_largest_connected_components()`, enabling users to define - how the size of a face is computed (the size of the connected component is the sum of the sizes of its faces). - If no property map is passed, the behavior is unchanged to previous versions: the size - of a connected component is the number of faces it contains. - - 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. +- **Breaking change**: the old API using iterators and overloads for + optional parameters is now removed (it was deprecated since CGAL + 4.12). The current (and now only) API uses ranges and Named + Parameters. -### IO Streams - - **Breaking change:** The API of `CGAL::Color` has been cleaned up. +- Added the possibility to use the named parameter `neighbor_radius` + to use spherical neighbor queries instead of K-nearest neighbors + queries for the following functions: + `CGAL::bilateral_smooth_point_set()`, + `CGAL::jet_estimate_normals()`, `CGAL::jet_smooth_point_set()`, + `CGAL::mst_orient_normals()`, `CGAL::pca_estimate_normals()` and + `CGAL::remove_outliers()`. ### Shape Detection - - Added a new generic implementation of region growing. - - New region growing can be launched on points in 2D and 3D and on a face graph. - - **Breaking change:** ShapeDetectionTraits is renamed to EfficientRANSACTraits. - - **Breaking change:** Shape_detection_3 namespace is renamed to Shape_detection. -### 3D Boolean Operations on Nef Polyhedra - - Added a function to convert a Nef_polyhedron_3 to a polygon soup: `CGAL::convert_nef_polyhedron_to_polygon_soup()` +- Added a new generic implementation of region growing. -### 2D and 3D Linear Geometry Kernel - - Add `ComputeApproximateAngle_3` in the 2D/3D Kernel concept to compute - the approximate dihedral angle between 2 vectors. Corresponding functors - in the model (`Compute_approximate_angle_3`) and free function (`approximate_angle`) - are also added. - - The following objects are now hashable and thus trivially usable - with `std::unordered_set` and `std::unordered_map`: - `CGAL::Aff_transformation_2`, `CGAL::Aff_transformation_3`, - `CGAL::Bbox_2`, `CGAL::Bbox_3`, `CGAL::Circle_2`, - `CGAL::Iso_cuboid_3`, `CGAL::Iso_rectangle_2`, `CGAL::Point_2`, - `CGAL::Point_3`, `CGAL::Segment_2`, `CGAL::Segment_3`, - `CGAL::Sphere_3`, `CGAL::Vector_2`, `CGAL::Vector_3`, - `CGAL::Weighted_point_2` and `CGAL::Weighted_point_3`. +- New region growing can be launched on points in 2D and 3D and on a + face graph. -### dD Geometry Kernel -- New exact kernel `Epeck_d` +- **Breaking change:** `ShapeDetectionTraits` is renamed to + `EfficientRANSACTraits`. + +- **Breaking change:** `Shape_detection_3` namespace is renamed to + `Shape_detection`. ### IO Streams + +- **Breaking change:** The API of `CGAL::Color` has been cleaned up. + - Added new functions to support some parts of the WKT file format: - `CGAL::read_point_WKT()` - `CGAL::read_multi_point_WKT()` @@ -140,6 +205,7 @@ Release date: September 2019 - `CGAL::write_multi_linestring_WKT()` - `CGAL:read_WKT()` + Release 4.14 ------------ From e4cf45bf26c69df74a75f5e74c20bcbc50516e13 Mon Sep 17 00:00:00 2001 From: Laurent Rineau Date: Mon, 30 Sep 2019 09:47:29 +0200 Subject: [PATCH 2/5] Let's be honest: the release will slip by a month --- Installation/CHANGES.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Installation/CHANGES.md b/Installation/CHANGES.md index 4e711a73a713..e35cbc777f43 100644 --- a/Installation/CHANGES.md +++ b/Installation/CHANGES.md @@ -4,7 +4,7 @@ Release History Release 5.0 ----------- -Release date: September 2019 +Release date: October 2019 ### Polygonal Surface Reconstruction (new package) From 5ce3541189feb32f64dabdae541e8235052198ca Mon Sep 17 00:00:00 2001 From: Laurent Rineau Date: Mon, 30 Sep 2019 09:47:37 +0200 Subject: [PATCH 3/5] Release announcement --- .../announcement/mailing-beta.eml | 120 +++++++++++++----- 1 file changed, 91 insertions(+), 29 deletions(-) diff --git a/Maintenance/public_release/announcement/mailing-beta.eml b/Maintenance/public_release/announcement/mailing-beta.eml index a3a24b3c777a..b62c97cc2f06 100644 --- a/Maintenance/public_release/announcement/mailing-beta.eml +++ b/Maintenance/public_release/announcement/mailing-beta.eml @@ -1,52 +1,114 @@ -Subject: CGAL 4.14 Beta 1 Released, Computational Geometry Algorithms Library +Subject: CGAL 5.0 Beta 1 Released, Computational Geometry Algorithms Library Content-Type: text/plain; charset="utf-8" Body: -The CGAL Open Source Project is pleased to announce the release 4.14 Beta 1 +The CGAL Open Source Project is pleased to announce the release 5.0 Beta 1 of CGAL, the Computational Geometry Algorithms Library. -CGAL version 4.14 Beta 1 is a public testing release. It should provide +CGAL version 5.0 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 4.14 in September. +release of the final version of CGAL 5.0 in October. Besides fixes and general enhancement to existing packages, the following -has changed since CGAL 4.13: +has changed since CGAL 4.14: -### 2D Periodic Hyperbolic Triangulations (new package) +### Polygonal Surface Reconstruction (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 - regular hyperbolic octagon with angles π/4 centered at the origin - of the Poincaré disk. Triangulations of the Bolza surface can be - seen as triangulations of the hyperbolic plane that are periodic - in the four directions defined by the sides of this regular - octagon. +- 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. -### 2D Hyperbolic Triangulations (new package) - - This package allows the computation of Delaunay Triangulations of - sets of points in the Poincaré disk, which is one of the - conformal models for the hyperbolic plane. +### dD Geometry Kernel -### The Heat Method (new package) +- New exact kernel `Epeck_d` -- This package provides an algorithm that solves the single- or - multiple-source shortest path problem by returning an - approximation of the geodesic distance for all vertices of a - triangle mesh to the closest vertex in a given set of source - vertices. -### Triangulated Surface Mesh Approximation (new package) +### 2D Triangulations -- This package implements the Variational Shape Approximation method - to approximate an input surface triangle mesh by a simpler surface - triangle mesh. +- Added range types and functions that return ranges, for example + for all vertices, which enables to use C++11 for-loops. +- **Breaking change**: Removed the functions + `CGAL::Constrained_triangulation_plus_2:: + vertices_in_constraint_{begin/end}(Vertex_handle va, Vertex_handle + vb) const;`, and + `CGAL::Constrained_triangulation_plus_2::remove_constraint((Vertex_handle + va, Vertex_handle vb)`, that is a pair of vertex handles is no + longer a key for a polyline constraint. Users must use a version + prior to 5.0 if they need this functionality. -See https://www.cgal.org/2019/03/04/cgal414-beta1/ for a complete list of +- **Breaking change**: Removed the deprecated classes + `CGAL::Regular_triangulation_euclidean_traits_2`, + `CGAL::Regular_triangulation_filtered_traits_2`. Users must use + a version prior to 5.0 if they need these classes. + +- **Breaking change**: The constructor and the `insert()` function + of `CGAL::Triangulation_2` which takes a range of points as + argument no longer performs a `spatial_sort()` of the points. + +- Add constructor and `insert()` function to `CGAL::Triangulation_2` + that takes a range of points with info. + +- **Breaking change**: The graph traits enabling CGAL's 2D + triangulations to be used as a parameter for any graph-based + algorithm of CGAL (or boost) have been improved to fully model the + `FaceGraph` concept. In addition, only the finite simplicies + (those not incident to the infinite vertex) of the 2D + triangulations are now visibile through this scope. The complete + triangulation can still be accessed as a graph, by using the graph + traits of the underlying triangulation data structure (usually, + `CGAL::Triangulation_data_structure_2`). + +- Introduced a new face base class, + `Triangulation_face_base_with_id_2` which enables storing + user-defined integer IDs in the face of any 2D triangulation, a + precondition to use some BGL algorithms. + + +### 3D Triangulations + +- Added range types and functions that return ranges, for example + for all vertices, which enables to use C++11 for-loops. + +- **Breaking change**: The constructor and the `insert()` function + of `CGAL::Triangulation_3` which takes a range of points as + argument no longer performs a `spatial_sort()` of the points. + +- Add constructor and `insert()` function to `CGAL::Triangulation_3` + that takes a range of points with info. + +### Point Set Processing + +- **Breaking change**: the old API using iterators and overloads for + optional parameters is now removed (it was deprecated since CGAL + 4.12). The current (and now only) API uses ranges and Named + Parameters. + +### Shape Detection + +- Added a new generic implementation of region growing. + +- New region growing can be launched on points in 2D and 3D and on a + face graph. + +- **Breaking change:** `ShapeDetectionTraits` is renamed to + `EfficientRANSACTraits`. + +- **Breaking change:** `Shape_detection_3` namespace is renamed to + `Shape_detection`. + + +See https://www.cgal.org/2019/09/30/cgal50-beta1/ for a complete list of changes. From 92e5b71e4d250a12c315be36833bdebd2b8a22d8 Mon Sep 17 00:00:00 2001 From: Laurent Rineau Date: Mon, 30 Sep 2019 11:25:06 +0200 Subject: [PATCH 4/5] New proposal for CHANGES.md --- Installation/CHANGES.md | 363 ++++++++++++++++++---------------------- 1 file changed, 165 insertions(+), 198 deletions(-) diff --git a/Installation/CHANGES.md b/Installation/CHANGES.md index e35cbc777f43..069923a9723d 100644 --- a/Installation/CHANGES.md +++ b/Installation/CHANGES.md @@ -1,209 +1,176 @@ Release History =============== -Release 5.0 +[Release 5.0](https://github.com/CGAL/cgal/releases/tag/releases%2FCGAL-5.0) ----------- Release date: October 2019 -### 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. - -### Solver Interface - - - Added concepts and models for solving Mixed Integer Programming - (MIP) problems with or without constraints. - -### dD Geometry Kernel - -- New exact kernel `Epeck_d` - -### 2D and 3D Linear Geometry Kernel - -- Add `ComputeApproximateAngle_3` in the 2D/3D Kernel concept to - compute the approximate dihedral angle between 2 - vectors. Corresponding functors in the model - (`Compute_approximate_angle_3`) and free function - (`approximate_angle`) are also added. - -- The following objects are now hashable and thus trivially usable - with `std::unordered_set` and `std::unordered_map`: - `CGAL::Aff_transformation_2`, `CGAL::Aff_transformation_3`, - `CGAL::Bbox_2`, `CGAL::Bbox_3`, `CGAL::Circle_2`, - `CGAL::Iso_cuboid_3`, `CGAL::Iso_rectangle_2`, `CGAL::Point_2`, - `CGAL::Point_3`, `CGAL::Segment_2`, `CGAL::Segment_3`, - `CGAL::Sphere_3`, `CGAL::Vector_2`, `CGAL::Vector_3`, - `CGAL::Weighted_point_2` and `CGAL::Weighted_point_3`. - -### 3D Boolean Operations on Nef Polyhedra - -- Added a function to convert a Nef_polyhedron_3 to a polygon soup: - `CGAL::convert_nef_polyhedron_to_polygon_soup()` - -### 2D Triangulations - -- Added range types and functions that return ranges, for example - for all vertices, which enables to use C++11 for-loops. - -- **Breaking change**: Removed the functions - `CGAL::Constrained_triangulation_plus_2:: - vertices_in_constraint_{begin/end}(Vertex_handle va, Vertex_handle - vb) const;`, and - `CGAL::Constrained_triangulation_plus_2::remove_constraint((Vertex_handle - va, Vertex_handle vb)`, that is a pair of vertex handles is no - longer a key for a polyline constraint. Users must use a version - prior to 5.0 if they need this functionality. - -- **Breaking change**: Removed the deprecated classes - `CGAL::Regular_triangulation_euclidean_traits_2`, - `CGAL::Regular_triangulation_filtered_traits_2`. Users must use - a version prior to 5.0 if they need these classes. - -- **Breaking change**: The constructor and the `insert()` function - of `CGAL::Triangulation_2` which takes a range of points as - argument no longer performs a `spatial_sort()` of the points. - -- Add constructor and `insert()` function to `CGAL::Triangulation_2` - that takes a range of points with info. - -- **Breaking change**: The graph traits enabling CGAL's 2D - triangulations to be used as a parameter for any graph-based - algorithm of CGAL (or boost) have been improved to fully model the - `FaceGraph` concept. In addition, only the finite simplicies - (those not incident to the infinite vertex) of the 2D - triangulations are now visibile through this scope. The complete - triangulation can still be accessed as a graph, by using the graph - traits of the underlying triangulation data structure (usually, - `CGAL::Triangulation_data_structure_2`). - -- Introduced a new face base class, - `Triangulation_face_base_with_id_2` which enables storing - user-defined integer IDs in the face of any 2D triangulation, a - precondition to use some BGL algorithms. - - -### 3D Triangulations - -- Added range types and functions that return ranges, for example - for all vertices, which enables to use C++11 for-loops. - -- **Breaking change**: The constructor and the `insert()` function - of `CGAL::Triangulation_3` which takes a range of points as - argument no longer performs a `spatial_sort()` of the points. - -- Add constructor and `insert()` function to `CGAL::Triangulation_3` - that takes a range of points with info. - -### Surface Mesh - -- New functions to read and write using the PLY format, - `CGAL::read_ply()` and `CGAL::write_ply()`, allowing to save and - load additional property maps of the surface mesh. +### CGAL now requires C++14 -### Polygon Mesh Processing - -- Added the function - `CGAL::Polygon_mesh_processing::non_manifold_vertices()`, which - can be used to collect all the non-manifold vertices (i.e. pinched - vertices, or vertices appearing in multiple umbrellas) of a mesh. - -- 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 function `CGAL::Polygon_mesh_processing::centroid()`, - which computes the centroid of a closed triangle mesh. - -- Added the functions - `CGAL::Polygon_mesh_processing::stitch_boundary_cycle()` and - `CGAL::Polygon_mesh_processing::stitch_boundary_cycles()`, which - can be used to try and merge together geometrically compatible but - combinatorially different halfedges that belong to the same - boundary cycle. - -- It is now possible to pass a face-size property map to - `CGAL::Polygon_mesh_processing::keep_large_connected_components()` - and - `CGAL::Polygon_mesh_processing::keep_largest_connected_components()`, - enabling users to define how the size of a face is computed (the - size of the connected component is the sum of the sizes of its - faces). If no property map is passed, the behavior is unchanged - to previous versions: the size of a connected component is the - number of faces it contains. - -- 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. - -### 3D Point Set - -- The PLY IO functions now take an additional optional parameter to - read/write comments from/in the PLY header. - -### Point Set Processing - -- **Breaking change**: the old API using iterators and overloads for - optional parameters is now removed (it was deprecated since CGAL - 4.12). The current (and now only) API uses ranges and Named - Parameters. - -- Added the possibility to use the named parameter `neighbor_radius` - to use spherical neighbor queries instead of K-nearest neighbors - queries for the following functions: - `CGAL::bilateral_smooth_point_set()`, - `CGAL::jet_estimate_normals()`, `CGAL::jet_smooth_point_set()`, - `CGAL::mst_orient_normals()`, `CGAL::pca_estimate_normals()` and - `CGAL::remove_outliers()`. - -### Shape Detection - -- Added a new generic implementation of region growing. - -- New region growing can be launched on points in 2D and 3D and on a - face graph. - -- **Breaking change:** `ShapeDetectionTraits` is renamed to - `EfficientRANSACTraits`. - -- **Breaking change:** `Shape_detection_3` namespace is renamed to - `Shape_detection`. - -### IO Streams - -- **Breaking change:** The API of `CGAL::Color` has been cleaned up. - -- Added new functions to support some parts of the WKT file format: - - `CGAL::read_point_WKT()` - - `CGAL::read_multi_point_WKT()` - - `CGAL::read_linestring_WKT()` - - `CGAL::read_multi_linestring_WKT()` - - `CGAL::read_polygon_WKT()` - - `CGAL::read_multi_polygon_WKT()` - - `CGAL::write_point_WKT()` - - `CGAL::write_polygon_WKT()` - - `CGAL::write_linestring_WKT()` - - `CGAL::write_multi_point_WKT()` - - `CGAL::write_multi_polygon_WKT()` - - `CGAL::write_multi_linestring_WKT()` - - `CGAL:read_WKT()` +- 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). + +### [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 + 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) + - **Breaking change:** The concept `ShapeDetectionTraits` has been renamed to [`EfficientRANSACTraits`](https://doc.cgal.org/5.0/Shape_detection/classEfficientRANSACTraits.html). + - **Breaking change:** The `Shape_detection_3` namespace has been renamed to [`Shape_detection`](https://doc.cgal.org/5.0/Shape_detection/annotated.html). + - 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`](https://doc.cgal.org/5.0/BGL/classFaceGraph.html) concept. Learn more about this new algorithm with this [blog entry](https://www.cgal.org/2019/07/30/Shape_detection/). + +### [dD Geometry Kernel](https://doc.cgal.org/5.0/Manual/packages.html#PkgKernelD) + - A new exact kernel, [`Epeck_d`](https://doc.cgal.org/5.0/Kernel_d/structCGAL_1_1Epeck__d.html), is now available. + +### [2D and 3D Linear Geometry Kernel](https://doc.cgal.org/5.0/Manual/packages.html#PkgKernel23) + - Added [`ComputeApproximateAngle_3`](https://doc.cgal.org/5.0/Kernel_23/classKernel_1_1ComputeApproximateAngle__3.html) + in the 2D/3D Kernel concepts to compute the approximate dihedral angle between 2 vectors. Corresponding functors + 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)) + are also added. + - 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`, + `CGAL::Iso_cuboid_3`, `CGAL::Iso_rectangle_2`, `CGAL::Point_2`, + `CGAL::Point_3`, `CGAL::Segment_2`, `CGAL::Segment_3`, + `CGAL::Sphere_3`, `CGAL::Vector_2`, `CGAL::Vector_3`, + `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) + 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 + (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. + - Added the shape smoothing function [`smooth_shape()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__PMP__meshing__grp.html#gaaa083ec78bcecf351e04d1bbf460b4a2), + which can be used to smooth the surface of a triangle mesh, using the mean curvature flow to perform noise removal. + (See also the new entry in the [User Manual](https://doc.cgal.org/5.0/Polygon_mesh_processing/index.html#title8)) + - Added the function [`CGAL::Polygon_mesh_processing::centroid()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__measure__grp.html#ga6da5119ce2c50729fda11a90ae7fb9ba), + which computes the centroid of a closed triangle mesh. + - Added the functions [`CGAL::Polygon_mesh_processing::stitch_boundary_cycle()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__PMP__repairing__grp.html#ga9c12c4878c08a117b3733bb45f1a34cf) + and [`CGAL::Polygon_mesh_processing::stitch_boundary_cycles()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__PMP__repairing__grp.html#ga24d5ae37f62064b3fc576ba48a4ccc63), + which can be used to try and merge together geometrically compatible but combinatorially different halfedges + that belong to the same boundary cycle. + - It is now possible to pass a face-size property map to [`CGAL::Polygon_mesh_processing::keep_large_connected_components()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__keep__connected__components__grp.html#ga48e7b3e6922ee78cf8ce801e3e325d9a) + and [`CGAL::Polygon_mesh_processing::keep_largest_connected_components()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__keep__connected__components__grp.html#ga68c6c29dfc6a26a6a2f8befe6944f19d), enabling users to define + how the size of a face is computed (the size of the connected component is the sum of the sizes of its faces). + If no property map is passed, the behavior is unchanged to previous versions: the size + of a connected component is the number of faces it contains. + - Added the function [`CGAL::Polygon_mesh_processing::non_manifold_vertices()`](https://doc.cgal.org/5.0/Polygon_mesh_processing/group__PMP__repairing__grp.html#ga36098d2415efd0604b7b996163bc22db), + which can be used to collect all the non-manifold vertices (i.e. pinched vertices, + 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 + 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) + 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), + [`CGAL::jet_smooth_point_set()`](https://doc.cgal.org/5.0/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga549402c0a8a8b6b71875181e93961521), + [`CGAL::mst_orient_normals()`](https://doc.cgal.org/5.0/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga50c98d5c5ae5535bce6f32eddbd03f33), + [`CGAL::pca_estimate_normals()`](https://doc.cgal.org/5.0/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#ga8c642da96a025ab32445aeb6cc219b0b) and + [`CGAL::remove_outliers()`](https://doc.cgal.org/5.0/Point_set_processing_3/group__PkgPointSetProcessing3Algorithms.html#gafd0b5a21ec5042e4bca09cb43f1847f9). + +### [2D Triangulations](https://doc.cgal.org/5.0/Manual/packages.html#PkgTriangulation2) + - **Breaking change**: Removed the deprecated functions `CGAL::Constrained_triangulation_plus_2:: + vertices_in_constraint_{begin/end}(Vertex_handle va, Vertex_handle vb) const;`, + and `CGAL::Constrained_triangulation_plus_2::remove_constraint(Vertex_handle va, Vertex_handle vb)`, + that is a pair of vertex handles is no longer a key for a polyline constraint. + Users must use a version prior to 5.0 if they need this functionality. + - **Breaking change**: Removed the deprecated classes `CGAL::Regular_triangulation_euclidean_traits_2`, + `CGAL::Regular_triangulation_filtered_traits_2`. Users must use a version prior to 5.0 if they need these classes. + - **Breaking change**: The [graph traits](https://doc.cgal.org/5.0/BGL/group__PkgBGLTraits.html) enabling CGAL's 2D triangulations to be used as a parameter + for any graph-based algorithm of CGAL (or boost) have been improved to fully model the [`FaceGraph`](https://doc.cgal.org/5.0/BGL/classFaceGraph.html) concept. + In addition, only the finite simplicies (those not incident to the infinite vertex) of the 2D triangulations + are now visibile through this scope. The complete triangulation can still be accessed as a graph, + by using the graph traits of the underlying triangulation data structure (usually, + [`CGAL::Triangulation_data_structure_2`](https://doc.cgal.org/5.0/TDS_2/classCGAL_1_1Triangulation__data__structure__2.html)). + - **Breaking change**: Insertion of a range of points (either via constructors or `insert()` functions) in a + [`CGAL::Triangulation_2`](https://doc.cgal.org/latest/Triangulation_2/classCGAL_1_1Triangulation__2.html) + no longer performs spatial sorting before insertion. Consequently, the combinatorics of the triangulation will now + correspond faithfully to the order of the points within the range. Note that this change only affects the base class + `Triangulation_2` and not any derived class, such as `Delaunay_triangulation_2`. + - Added a new [constructor](https://doc.cgal.org/5.0/Triangulation_2/classCGAL_1_1Triangulation__2.html#a6cfa7d3aaa375a25d217858b49e2eb07=) + and [`insert()`](https://doc.cgal.org/5.0/Triangulation_2/classCGAL_1_1Triangulation__2.html#ac5e9bc8adef80dc01a0b31c2d0234545) + function to [`CGAL::Triangulation_2`](https://doc.cgal.org/5.0/Triangulation_2/classCGAL_1_1Triangulation__2.html) + that takes a range of points with info. + - Introduced a new face base class, [`Triangulation_face_base_with_id_2`](https://doc.cgal.org/5.0/BGL/classCGAL_1_1Triangulation__face__base__with__id__2.html) + which enables storing user-defined integer IDs in the face of any 2D triangulation, a precondition to use some + BGL algorithms. + - Added range types and functions that return ranges, for example for all vertices, enabling the use of `C++11` `for`-loops. + See [this new example](https://doc.cgal.org/5.0/Triangulation_2/Triangulation_2_2for_loop_2_8cpp-example.html) for a usage demonstration. + +### [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) + which takes a range of points as argument no longer performs a call to `spatial_sort()` of the points. + Consequently, the combinatorics of the triangulation will now + correspond faithfully to the order of the points within the + range. Note that this change only affects the base class + `Triangulation_3` and not any derived class, such as + `Delaunay_triangulation_3`. + - Added constructor and [`insert()`](https://doc.cgal.org/5.0/Triangulation_3/classCGAL_1_1Triangulation__3.html#a8aa85f88733d30aa3ec5385538e13ace) + function to `CGAL::Triangulation_3` that takes a range of points with info. + - Added range types and functions that return ranges, for example for all vertices, which enables to use C++11 for-loops. + See [this new example](https://doc.cgal.org/5.0/Triangulation_3/Triangulation_3_2for_loop_8cpp-example.html) for a usage demonstration. + +### [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), + 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. + +### [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) + +### [IO Streams](https://doc.cgal.org/5.0/Manual/packages.html#PkgStreamSupport) +- **Breaking change:** The API of [`CGAL::Color`](https://doc.cgal.org/5.0/Stream_support/classCGAL_1_1Color.html) has been cleaned up. +- Added new functions to support some parts of the WKT file format: + * [`CGAL::read_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#gad2872abfe6fcf17d705d38567fdd6248) + * [`CGAL::read_point_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#gadbd2705b183e467507abd2f167446eba) + * [`CGAL::read_multi_point_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#ga4fb72e49a1fd385bbed35ea20297aa8d) + * [`CGAL::read_linestring_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#gaaa236308b9da5dbf217ef281fdb55de4) + * [`CGAL::read_multi_linestring_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#gad6046c7f9d36512b8a014be82c1e2220) + * [`CGAL::read_polygon_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#gaa36ccd3ac4b3fe3e3fd8a76715c56b9a) + * [`CGAL::read_multi_polygon_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#ga4ceaa71b9cb3b3f7984bed19afff6fc6) + * [`CGAL::write_point_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#gab1a2d277b43c218bf128a2056eb53ced) + * [`CGAL::write_polygon_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#gab5365a4726893aa4f51739ede63f5a09) + * [`CGAL::write_linestring_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#gaa37ed77d1a01567b93c872a48198efa6) + * [`CGAL::write_multi_point_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#ga98de4b4e5cccb370febe5daf66bb582d) + * [`CGAL::write_multi_polygon_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#ga4ded40ab50f57e0b410640e28964935e) + * [`CGAL::write_multi_linestring_WKT()`](https://doc.cgal.org/5.0/Stream_support/group__PkgStreamSupportRef.html#ga219987f7a9c0b871c1733aa0c38f26b3) Release 4.14 From 81e0e08d1b3a7adf1e0a03d6c4c3ef837f8b8ac8 Mon Sep 17 00:00:00 2001 From: Laurent Rineau Date: Mon, 30 Sep 2019 12:04:32 +0200 Subject: [PATCH 5/5] Updated email --- .../announcement/mailing-beta.eml | 168 +++++++++--------- 1 file changed, 80 insertions(+), 88 deletions(-) diff --git a/Maintenance/public_release/announcement/mailing-beta.eml b/Maintenance/public_release/announcement/mailing-beta.eml index b62c97cc2f06..0af72897ae03 100644 --- a/Maintenance/public_release/announcement/mailing-beta.eml +++ b/Maintenance/public_release/announcement/mailing-beta.eml @@ -10,102 +10,94 @@ CGAL version 5.0 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 October. + +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). + + Besides fixes and general enhancement to existing packages, the following has changed since CGAL 4.14: -### Polygonal Surface Reconstruction (new package) +Polygonal Surface Reconstruction (new package) - This package provides a method for piecewise planar object - reconstruction from point clouds. The method takes as input an + 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. - - -### dD Geometry Kernel - -- New exact kernel `Epeck_d` - - -### 2D Triangulations - -- Added range types and functions that return ranges, for example - for all vertices, which enables to use C++11 for-loops. - -- **Breaking change**: Removed the functions - `CGAL::Constrained_triangulation_plus_2:: - vertices_in_constraint_{begin/end}(Vertex_handle va, Vertex_handle - vb) const;`, and - `CGAL::Constrained_triangulation_plus_2::remove_constraint((Vertex_handle - va, Vertex_handle vb)`, that is a pair of vertex handles is no - longer a key for a polyline constraint. Users must use a version - prior to 5.0 if they need this functionality. - -- **Breaking change**: Removed the deprecated classes - `CGAL::Regular_triangulation_euclidean_traits_2`, - `CGAL::Regular_triangulation_filtered_traits_2`. Users must use - a version prior to 5.0 if they need these classes. - -- **Breaking change**: The constructor and the `insert()` function - of `CGAL::Triangulation_2` which takes a range of points as - argument no longer performs a `spatial_sort()` of the points. - -- Add constructor and `insert()` function to `CGAL::Triangulation_2` - that takes a range of points with info. - -- **Breaking change**: The graph traits enabling CGAL's 2D - triangulations to be used as a parameter for any graph-based - algorithm of CGAL (or boost) have been improved to fully model the - `FaceGraph` concept. In addition, only the finite simplicies - (those not incident to the infinite vertex) of the 2D - triangulations are now visibile through this scope. The complete - triangulation can still be accessed as a graph, by using the graph - traits of the underlying triangulation data structure (usually, - `CGAL::Triangulation_data_structure_2`). - -- Introduced a new face base class, - `Triangulation_face_base_with_id_2` which enables storing - user-defined integer IDs in the face of any 2D triangulation, a - precondition to use some BGL algorithms. - - -### 3D Triangulations - -- Added range types and functions that return ranges, for example - for all vertices, which enables to use C++11 for-loops. - -- **Breaking change**: The constructor and the `insert()` function - of `CGAL::Triangulation_3` which takes a range of points as - argument no longer performs a `spatial_sort()` of the points. - -- Add constructor and `insert()` function to `CGAL::Triangulation_3` - that takes a range of points with info. - -### Point Set Processing - -- **Breaking change**: the old API using iterators and overloads for - optional parameters is now removed (it was deprecated since CGAL - 4.12). The current (and now only) API uses ranges and Named - Parameters. - -### Shape Detection - -- Added a new generic implementation of region growing. - -- New region growing can be launched on points in 2D and 3D and on a - face graph. - -- **Breaking change:** `ShapeDetectionTraits` is renamed to - `EfficientRANSACTraits`. - -- **Breaking change:** `Shape_detection_3` namespace is renamed to - `Shape_detection`. + 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 (major changes) + +- 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/ + + +dD Geometry Kernel + +- A new exact kernel, Epeck_d, is now available. + + +2D and 3D Triangulations + +- BREAKING CHANGE: Several deprecated functions and classes have been + removed. See the full list of breaking changes in the release + notes. + +- BREAKING CHANGE: Insertion of a range of points (either via + constructors or insert() functions) in a CGAL::Triangulation_2 and + CGAL::Triangulation_3 no longer performs spatial sorting before + insertion. Consequently, the combinatorics of the triangulation + will now correspond faithfully to the order of the points within + the range. Note that this change only affects the base classes + CGAL::Triangulation_[23] and not any derived classes, such as + Delaunay_triangulation_[23]. + + +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. + + +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. See https://www.cgal.org/2019/09/30/cgal50-beta1/ for a complete list of