CGAL 6.2

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

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

General Changes

• The new list of supported compilers is:
  • Visual C++ 15.9, 16.10, 17.14, 18.0 (from Visual Studio 2017, 2019, 2022, and 2026) or later
  • Gnu g++ 13.3.0 or later (on Linux)
  • LLVM Clang version 22.0.0 or later (on Linux)
  • Apple Clang compiler versions 14.0.0 or later (on macOS)
• The minimal supported version of Boost is still 1.74.0, but only versions 1.79.0 and later were tested.

2D Alpha Wrapping (new package)

• This component takes a polygon soup, a 2D segment soup, and/or a 2D point set as input, and generates a valid (watertight, intersection-free and 1-manifold) multi-polygon that strictly encloses the input. The algorithm proceeds by shrink-wrapping and refining a 2D Delaunay triangulation starting from a loose bounding box of the input. Two user-defined parameters, alpha and offset, offer control over the maximum size of cavities where the shrink-wrapping process can enter, and the tightness of the final polygon(s) to the input, respectively. Once combined, these parameters provide a means to trade fidelity to the input for complexity of the output.

  See also the associated news entry.

Generalized Barycentric Coordinates 3 (new package)

• This package provides functions to compute various types of generalized barycentric coordinates (Wachspress, mean value, discrete harmonic and tetrahedron coordinates) for points located inside closed convex 3D polyhedra.

Polygon Mesh Processing (major changes)

• The “Polygon Mesh Processing” package has been reorganized into several packages. “Polygon Mesh Processing” retains the core functionalities, while advanced and specialized features have been moved to dedicated packages:
  • Boolean Operations On Meshes: algorithms for Boolean operations on polygon meshes; clipping, splitting, and slicing with planes, boxes, or other meshes; and kernel computations.
  • Meshing and Remeshing of Polygon Meshes: algorithms for meshing and remeshing, such as triangulation, refinement, simplification, optimization, and smoothing.
  • Polygon Mesh Repair: tools for detecting and correcting combinatorial and geometric defects in polygon meshes and polygon soups, including face orientation, hole filling, removal of degeneracies, and boundary stitching. This split does not induce any breaking change and is fully transparent: header includes such as #include <CGAL/Polygon_mesh_processing/XXX.h> do not need to be changed and will include the appropriate header from the new packages.

2D and 3D Linear Geometry Kernel

• Breaking change: The functors Do_intersect_2 and Do_intersect_3 for intersection now correctly honor the definition of a Circle_2 (resp. Sphere_3) as a 1-manifold (resp. 2-manifold) without borders. In other words, a circle is not a disk, and a sphere is not a ball. Consequently, Circle_2/Segment_2, Sphere_3/Bbox_3, Sphere_3/Iso_cuboid_3 no longer consider inclusion as an intersection. This behavior is consistent with other intersection combinations involving Circle_2 and Sphere_3. The former behavior can be reproduced with:
  • !Has_on_unbounded_side_2::operator(Circle_2, Segment_2),
  • !Has_on_unbounded_side_2::operator(Circle_2, Iso_rectangle_2), or
  • !Has_on_unbounded_side_3::operator(Sphere_3, Iso_cuboid_3)
• Added a new concept, CompareProjectionAlongDirection_3, to the Kernel concept to compare the order of point projections onto a line. Corresponding functors in the model, Compare_projection_along_direction_3, and free function, compare_projection_along_direction(), have been added.

Intersecting Sequences of dD Iso-oriented Boxes

• The function CGAL::box_intersection_d() now supports ranges with different box types.
• Added the box type CGAL::Box_with_info_d<FT, dim, Info>, which stores a variable of type Info accessible via the class member function info().

2D Arrangements

• Introduced a Geometry Traits concept for arrangement on surfaces that enables the provision of the disconnected portions of an approximation of a curve within a given bounding box.
• The class CGAL::Arr_linear_traits_2 is now a model of the new concept.
• Added overloads of CGAL::draw(Arrangement_on_surface_2& arr, Bbox& bbox, ...) that enable the drawing of arrangements induced by unbounded curves.
• Introduced the concept AosTraits::Do_intersect_2. A model of this concept must provide an operator that accepts two x-monotone curves and a boolean flag that indicates whether common endpoints should be considered or ignored. The operator determines whether the curves intersect, and it can be used with an inexact-construction kernel.

2D Intersection of Curves

• The function CGAL::do_curves_intersect(), which assumed open curves, has been deprecated and replaced by the function CGAL::Surface_sweep_2::do_intersect(). Notice: (i) the introduction of the new namespace Surface_sweep_2, and (ii) the addition of the closed parameter, which defaults to true. To match the behavior of the deprecated function, set closed to false.

2D Regularized Boolean Set-Operations

• Optimized do_intersect():
  • (i) made it robust even with an inexact-predicates kernel, and
  • (ii) made it quit once an intersection is detected. (In the past, the intersection was computed in one phase and examined in a subsequent phase.) This optimization somehow breaks backward compatibility as follows: the variants of the free function do_intersect() that accept a third optional parameter, namely UsePolylines, which determines whether the boundaries of the input polygons are treated as cyclic sequences of (x-monotone) segments or as a cyclic sequences of (x-monotone) polylines, do not accept this third parameter any longer. (This third optional parameter was introduced a few years ago, and now abandoned only for do_intersect().)

3D Convex hull

• Added the function CGAL::Convex_hull_3::do_intersect(), which can be used to test for intersection between two convex hulls.
• Added the function CGAL::extreme_point_3(), which returns the farthest point of a convex hull in a given direction.
• Added the class CGAL::Convex_hull_hierarchy_3, which represents a convex hull, and is optimized for the functions above.

2D Triangulations

• Added the function insert_unique_constraints() to the class CGAL::Constrained_Delaunay_triangulation_2 identical to the function [insert_constraints()](https://doc.cgal.org/6.2/Triangulation_...

CGAL 6.1.2

CGAL-6.1.2 is a bug-fix release.

See on Github the list of bugs that were solved since CGAL-6.1.1.

Full Changelog: v6.1.1...v6.1.2

CGAL 6.2-beta1

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

CGAL version 6.2 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 6.2 in June or July 2026.

Change log available at https://www.cgal.org/2026/05/21/cgal62-beta1/.

CGAL 6.1.1

CGAL-6.1.1 is a bug-fix release.

See on Github the list of bugs that were solved since CGAL-6.1.

Full Changelog: v6.1...v6.1.1

CGAL 6.0.3

CGAL-6.0.3 is a bug-fix release.

See on Github the list of bugs that were solved since CGAL-6.0.2.

Full Changelog: v6.0.2...v6.0.3

CGAL 6.1

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

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

General Changes

• The new list of supported compilers is:
  • Visual C++ 15.9, 16.10, 17.0 (from Visual Studio 2017, 2019 and 2022) or later
  • Gnu g++ 12.2.0 or later (on Linux)
  • LLVM Clang version 20.1.6 or later (on Linux)
  • Apple Clang compiler versions 12.0.5 and 12.0.5 (on macOS)
• The minimal supported version of Boost is now 1.74.0.

3D Constrained Triangulations (new package)

• This package implements the construction of a 3D Constrained Delaunay triangulation. This triangulation is a generalization of a 3D Delaunay Triangulation which conforms to the set of faces of a 3D piecewise linear complex (PLC), ensuring that these faces are part of the triangulation. As not all PLCs are tetrahedralizable, the algorithm may insert Steiner points to construct the constrained triangulation. The main entry point is the function CGAL::make_conforming_constrained_Delaunay_triangulation_3().

3D Isosurfacing (new package)

• This package provides algorithms to extract isosurfaces from scalar fields. The algorithms provided in this first version include Marching Cubes, Topologically Correct Marching Cubes, and Dual Contouring. The algorithm is generic with respect to the scalar field representation (implicit function, discrete values, …) and the discretization data structure (Cartesian grid, octree, …). The output is an indexed face set that stores an isosurface in the form of a surface mesh.

dD Fréchet Distance (new package)

• This package provides functions for computing the Fréchet distance of polylines in any dimension under the Euclidean metric.

2D Triangulations on Hyperbolic Surfaces (new package)

• This package enables building and handling triangulations of closed orientable hyperbolic surfaces. It offers functions for the generation of the triangulation from a convex fundamental domain, the Delaunay flip algorithm, and the construction of a portion of the lift of the triangulation in the Poincaré disk. A method is offered that generates such domains in genus two.

  See also the associated news entry.

Polygon Repair

• Added the non-zero rule (areas with non-zero winding number are kept), as well as two functions to compute the conservative inner and outer hull of similar polygons:

  • CGAL::Polygon_repair::join()
  • CGAL::Polygon_repair::intersect()

  See also the associated news entry.

Polygon Mesh Processing

• Added the parameter apply_iterative_snap_rounding to the function CGAL::Polygon_mesh_processing::autorefine_triangle_soup(). When set to true, the coordinates are rounded to fit in double and may perform additional subdivisions to ensure the output is free of self-intersections. See also the associated news entry.
• Added the function CGAL::Polygon_mesh_processing::approximated_centroidal_Voronoi_diagram_remeshing() to remesh triangle meshes. This remeshing algorithm uses clustering on polygonal meshes as to approximate a Centroidal Voronoi Diagram construction, and can move vertices as to recover sharp features and corners. See also the associated news entry.
• New implementation of CGAL::Polygon_mesh_processing::clip() and CGAL::Polygon_mesh_processing::split() with a plane as clipper that is much faster and is now able to handle non-triangulated surface meshes. See also the associated news entry.
• Added the function CGAL::Polygon_mesh_processing::refine_with_plane(), which enables users to refine a mesh with its intersection with a plane.
• Added a function in the visitor of the corefinement based methods to trace faces in the output meshes which correspond to coplanar faces of the input.
• Added the function CGAL::Polygon_mesh_processing::discrete_mean_curvature() and CGAL::Polygon_mesh_processing::discrete_Gaussian_curvature() to evaluate the discrete curvature at a vertex of a mesh.
• Added the function CGAL::Polygon_mesh_processing::angle_sum() to compute the sum of the angles around a vertex.

Point Set Processing

• Added CGAL::poisson_eliminate(), which can be used to downsample a point cloud to a target size while providing Poisson disk property, i.e., a larger minimal distance between points.

CGAL and the Boost Graph Library (BGL)

• Added the function dijkstra_shortest_path(), which can be used to compute the geometrically shortest sequence of halfedges between two vertices.
• Added the function CGAL::Euler::remove_degree_2_vertex(), which enables users to remove vertices which have exactly two incident edges.

2D Arrangements

• Breaking change: Renamed the concept AosApproximateTraits_2 to AosApproximatePointTraits_2 to make room for the new concept AosApproximateTraits_2. This concept requires the provision of a functor called Approximate_2 that has an operator that approximates the coordinates of a point.
• Breaking change: The concept AosApproximateTraits_2 now refines the concept AosApproximatePointTraits_2 and requires the provision of a functor called Approximate_2. In addition to an operator that approximates the coordinates of a point, it also requires the provision of (i) an operator that approximates a points, and (ii) an operator that approximates a curve.
• Renamed the prefix of the names of all concepts in the Arrangement_on_surface_2 package from “Arrangement” to “Aos”.
• Introduced two traits decorators, namely CGAL::Arr_tracing_traits_2 and CGAL::Arr_counting_traits_2, which can be used to extract debugging and informative metadata about the traits in use while a program is being executed.
• Fixed the Landmark point-location strategy so that it can be applied to arrangements on a sphere.
• Fixed a bug in the extensions of vertex and halfedge types of the DCEL when used to instantiate Arrangement_with_history_2 or similar arrangement classes that derive from Arrangement_2.
• Fixed do_intersect() of a 2D Arrangement with a curve.

Triangulations

• All triangulations now offer the functions point(Vertex_handle) and point(Simplex, int), which enables users to access the geometric position of a vertex and of the i-th vertex of a simplex of a triangulation.

Poisson Surface Reconstruction

• Added a new mesh domain Poisson_mesh_domain_3 that integrates some optimizat...

CGAL 6.0.2

CGAL-6.0.2 is a bug-fix release.

See on Github the list of bugs that were solved since CGAL-6.0.1.

Full Changelog: v6.0.1...v6.0.2

CGAL 6.1-beta2

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

CGAL version 6.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 6.1 in Sept 2025.

The changelog is available at https://www.cgal.org/2025/09/17/cgal61-beta2/.

CGAL 5.6.3

CGAL-5.6.3 is a bug-fix release.

See on Github the list of bugs that were solved since CGAL-5.6.2.

CGAL 6.1-beta1

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

CGAL version 6.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 6.1 in Sept 2025.

Change log available at https://www.cgal.org/2025/07/07/cgal61-beta1/.