cgal/Maintenance/public_release/announcement/mailing-beta.eml

Subject: CGAL 5.1 Beta 2 Released, Computational Geometry Algorithms Library
Content-Type: text/plain; charset="utf-8"
Body:

The CGAL Open Source Project is pleased to announce the release 5.1 Beta 2
of CGAL, the Computational Geometry Algorithms Library.


CGAL version 5.1 Beta 2 is a public testing release. It should provide a
solid ground to report bugs that need to be tackled before the release
of the final version of CGAL 5.1 in September.


Besides fixes and general enhancement to existing packages, the following
has changed since CGAL 5.0:


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.

Surface Mesh Topology (new package)

-   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/

Installation

-   The CGAL_Core library no longer requires Boost.Thread, even if the
    g++ compiler is used.

Tutorials

-   Two new, detailed tutorials have been added:
    -   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.

    Both tutorials provide complete code.

    See https://doc.cgal.org/5.1/Manual/tutorials.html

Point Set Processing

-   Added wrapper functions for registration, using the Super4PCS and
    ICP algorithms implemented in the third party libraries OpenGR and
    libpointmatcher.


Surface Mesh Simplification

-   Added a new simplification method based on the quadric error defined
    by Garland and Heckbert.

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).

Intersecting Sequences of dD Iso-oriented Boxes

-   Added parallel versions of the functions CGAL::box_intersection_d()
    and CGAL::box_self_intersection_d().

Polygon Mesh Processing

-   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 parallel versions of the functions
    CGAL::Polygon_mesh_processing::does_self_intersect() and
    CGAL::Polygon_mesh_processing::self_intersections().
-   Added several mesh repair functions (see the complete changelog for
    more information).

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.


CGAL and the Boost Graph Library (BGL)

-   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.

See https://www.cgal.org/2020/07/28/cgal51-beta2/ for a complete list of
changes.


The CGAL project is a collaborative effort to develop a robust,
easy-to-use, and efficient C++ software library of geometric data
structures and algorithms, like
- triangulations (2D constrained triangulations, Delaunay triangulations
  and periodic triangulations in 2D and 3D),
- Voronoi diagrams (for 2D and 3D points, 2D additively weighted
  Voronoi diagrams, and segment Voronoi diagrams),
- Boolean operations on polygons and polyhedra,
- regularized Boolean operations on polygons with curved arcs
- arrangements of curves,
- mesh generation (2D, 3D and surface mesh generation,
  surface mesh subdivision and parametrization),
- alpha shapes (in 2D and 3D),
- convex hull algorithms (in 2D, 3D and dD),
- operations on polygons (straight skeleton and offset polygon),
- search structures (kd trees for nearest neighbor search, and
  range and segment trees),
- interpolation (natural neighbor interpolation and placement of
  streamlines),
- optimization algorithms (smallest enclosing sphere of points or
  spheres, smallest enclosing ellipsoid of points, principal
  component analysis).




Some modules are distributed under the terms of the LGPL Open Source
license (GNU Lesser General Public License v3 or later versions).
Most modules are distributed under the terms of the GPL Open Source
license (GNU General Public License v3 or later versions).
If your intended usage does not meet the criteria of the
aforementioned licenses, a commercial license can be purchased from
GeometryFactory (http://www.geometryfactory.com/).


For further information and for downloading the library and its
documentation, please visit the CGAL web site: https://www.cgal.org/