CGAL users discussion list

[Laurent Rineau <>]

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

CGAL version 5.6 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.6 in July 2023.

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

General Changes

-   Breaking change: Package-specific assertions, preconditions, and
    postconditions (such as CGAL_triangulation_assertion) have been
    removed. Corresponding CGAL-wide versions (such as CGAL_assertion)
    should be used instead.

Shape Detection (major changes)

-   Breaking change: The region growing part of the package have been
    reworked to fix design issues introduced with the handling of
    FaceGraph models. In particular, the notion of Item has been
    introduced to reference an element in the input range of elements.
    Region maps now operates on Item and no longer on the value type of
    the input range.
-   Breaking change: The method update() in the concept RegionType now
    returns a Boolean instead of void, that is used inside the class
    Region_growing for detecting if the input conditions for the new
    region are satisfied. This change affects only user-defined types of
    regions.
-   Breaking change: The constructors of all models used together with
    the region growing algorithm now enable users to provide parameters
    through the named parameters mechanism.
-   All fitting classes in the region growing framework are now using
    better versions of the region conditions, more precise and faster,
    including the correct normal orientations.
-   Added new models of the concept RegionType for getting linear
    regions in a set of 2D and 3D segments and on 2D and 3D polylines.
-   Added the class Polyline_graph for extracting a set of polylines
    from a face graph, which splits this graph into a set of
    user-defined regions.
-   Added new shapes to the Region Growing algorithm on a point set:
    circles in 2D, spheres in 3D, and cylinders in 3D.

2D Straight Skeleton and Polygon Offsetting (major changes)

-   Added weighted straight skeletons: weighted straight skeletons are a
    generalization of straight skeletons. Contour edges are assigned a
    positive weight, which can be understood as assigning a speed to the
    wavefront spawned from the contour edge.
-   Added straight skeleton extrusion: this CGAL package now implements
    the extrusion of weighted straight skeletons of polygons with holes.
    The output is a closed, combinatorially 2-manifold surface triangle
    mesh. See also the news entry.

Combinatorial Maps, Generalized Maps, and Linear Cell Complex

-   Added a version that uses indices instead of handles as dart and
    attribute descriptors. As the indices are integers convertible from
    and to std::size_t, they can be used as index into vectors which
    store properties. To use the index version, Use_index must be
    defined and be equal to CGAL::Tag_true in the item class.

2D Arrangements

-   Introduced an overload function template, namely draw(arr), that
    renders arrangements based on the Basic_viewer_qt class template. As
    of now, only 2D arrangements on the plane induced by (i)
    segments, (ii) conics, and (iii) circular arcs or (linear) segments
    are supported.
-   Improved the traits class template that handles conics, namely
    Arr_conic_traits_2. This includes the following: 1. Fixed a couple
    of bugs and slightly optimized some functions. 2. Introduced
    functionality that approximates conics with polylines. (This is used
    to draw conic curves.) 3. Breaking change: Changed the interface to
    generate conic curves. In the past, curves where generated directly
    using the constructors of the conic and x-monotone conic constructs.
    Now, they are constructed via function objects provided by the
    traits. This eliminates the constructions of temporary kernels. The
    old functionality is obsolete, but still supported for a limited
    number of versions. It depends on a static member function of the
    traits. In a future version this function will no longer be static,
    implying that the old functionality will no longer be supported.
-   Introduced functionality that approximates circular segments with
    polylines. (This is used to draw conic curves.)

Polygon Mesh Processing

-   Added functions
    CGAL::Polygon_mesh_processing::region_growing_of_planes_on_faces()
    and CGAL::Polygon_mesh_processing::detect_corners_of_regions(),
    which enable partitioning a mesh into planar regions using the
    region growing algorithm from the Shape Detection package.

-   Added the functions
    CGAL::Polygon_mesh_processing::remesh_planar_patches() and
    CGAL::Polygon_mesh_processing::remesh_almost_planar_patches(), which
    can be used to remesh patches of coplanar faces in a mesh.

-   Added the function
    CGAL::Polygon_mesh_processing::surface_Delaunay_remeshing(), which
    can be used to remesh a surface triangle mesh using the Delaunay
    refinement algorithm from the 3D Mesh Generation package.

-   Added the function
    CGAL::Polygon_mesh_processing::remove_almost_degenerate_faces(),
    which can be used to remove badly shaped triangles faces in a mesh.

-   Added the functions
    CGAL::Polygon_mesh_processing::does_triangle_soup_self_intersect()
    and
    CGAL::Polygon_mesh_processing::triangle_soup_self_intersections() to
    identify and report self-intersections in a triangle soup, similarly
    to existing functions on triangle meshes.

-   Added the function
    CGAL::Polygon_mesh_processing::triangulate_polygons(), which allows
    users to triangulate polygon soups.

-   Added a named parameter to
    CGAL::Polygon_mesh_processing::smooth_shape() to disable the
    scaling, which otherwise aims to compensate volume loss during
    smoothing.

-   Deprecated the overloads of functions
    CGAL::Polygon_mesh_processing::triangulate_hole(),
    CGAL::Polygon_mesh_processing::triangulate_and_refine_hole(), and
    CGAL::Polygon_mesh_processing::triangulate_refine_and_fair_hole()
    which have output iterators for vertices and faces as parameter.
    They are replaced by overloads with two additional named parameters.


3D Mesh Generation

-   Added two new named parameters to the named constructor
    CGAL::create_labeled_image_mesh_domain() for automatic detection and
    protection of 1D-curves that lie at the intersection of three or
    more subdomains extracted from labeled images.
-   Added CGAL::Sizing_field_with_aabb_tree, a geometry-aware sizing
    field for feature edges in polyhedral domains.
-   Added new meshing criterion edge_min_size to avoid subdividing sharp
    edges that are shorter than a prescribed size bound.
-   Added new meshing criteria facet_min_size and cell_min_size to
    prevent Delaunay refinement from creating simplices smaller than a
    prescribed bound.
-   Deprecated usage of boost parameters in favor of function named
    parameters.


See https://www.cgal.org/2023/06/13/cgal56-beta1/ for a
complete list of changes.


The development of CGAL will then now on the future CGAL-6.0 (planned
for December 2023), with bug-fixes regularly backported to the branches
for CGAL-5.5.x and CGAL-5.6.x.

CGAL-6.0 will be the first release of CGAL requiring C++17 or later. It
will also support Qt6.


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 (https://www.geometryfactory.com/).


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

-- 
Laurent Rineau, PhD
R&D Engineer at GeometryFactory           http://www.geometryfactory.com/
Release Manager of the CGAL Project       http://www.cgal.org/