cgal

CGAL-5.2.3 is a bug-fix release.

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

CGAL-5.1.5 is a bug-fix release.

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

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

CGAL version 5.3 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.3 in July 2021.

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

Quadtrees, Octrees, and Orthtrees (new package)

• This package implements a tree data structure in which each node encloses a hypercubic section
  of space and each non-leave node has hypercubic children whose edge lengths are half its edge length.
  Such a data structure is known as a quadtree in 2D, an octree in 3D, and is generalized
  as an "orthtree" in higher dimensions.

Triangulations on the Sphere (new package)

• This package enables the construction and manipulation of Delaunay triangulations on the 2-sphere.
  Triangulations are built incrementally and can be modified by insertion or removal of vertices.
  Point location querying and primitives to build the dual Voronoi diagram are provided.

File Input / Output

• Point set, polygon soup, and polygon mesh file I/O functions have been harmonized and documented:
  • Point set I/O functions can be found in the packages Point_set_processing_3, and Point_set_3.
  • Polygon mesh I/O functions can be found in the package BGL.
  • Polygon soup I/O can be found in the package Stream_support.

A comprehensive list of the supported file formats is available in the Stream_support package here; inversely, the following page can be used to find out which CGAL data structures can be used given a specific file format.

Requirements

• The CMake minimal version is now 3.14.
• The GNU compiler g++ versions 6 and 7 are no longer tested. Only version 8.3 or later are supported

2D and 3D Linear Geometry Kernel

• Added is_translation(), is_scaling(), is_reflection(), and is_rotation() to the classes
  Aff_transformation_2
  and Aff_transformation_3,
  which enable determining if the transformations use a specialized representation internally.

2D Regularized Boolean Set-Operations

• Added documentation for the free functions oriented_side(const Point_2& p, ....)
  that accept a point and a polygon.
• Documentation has been improved across the whole package.

Polygon Mesh Processing

• Added the class CGAL::Polyhedral_envelope,
  providing a way to quickly check if a primitive (point, segment, or triangle)
  is within a polyhedral envelope around a set of triangles. It is based on the work of
  Bolun Wang, Teseo Schneider, Yixin Hu, Marco Attene, and Daniele Panozzo.
  "Exact and efficient polyhedral envelope containment check." (ACM Trans. Graph., 39-4, July 2020).
• Added more functions in the visitor of the corefinement based methods
  to track all edge creations.

Surface Mesh Topology

• Added the function CGAL::Surface_mesh_topology::Curves_on_surface_topology::is_homotopic_to_simple_cycle(),
  which can be used to determine whehter a closed path on a surface mesh can be continously
  transformed to a cycle without self intersection.

Surface Mesh Simplification

• Added a filtering mechanism so that costly tests get only applied to the next candidate for the edge collapse.
• Added the class Polyhedral_envelope_filter,
  which enables to perform mesh simplification inside a polyhedral envelope of the input mesh.

2D Polyline Simplification

• When polylines have common subsequences of vertices, these subsequences may now be simplifified simultaneously.

dD Triangulations

• Added the function insert_if_in_star()
  to the class CGAL::Regular_triangulation,
  which enables users to insert a point p in a regular triangulation on the condition that p
  appears post-insertion in the star of a user-specified, existing vertex.

2D and 3D Alpha Shapes

• Breaking change: The following deprecated classes have been removed: Alpha_shape_euclidean_traits_2,
  Weighted_alpha_shape_euclidean_traits_2, Alpha_shape_euclidean_traits_3, and
  Weighted_alpha_shape_euclidean_traits_3. All CGAL kernel can be used directly as models
  of the concepts of the 2D and 3D Alpha Shape packages.

Classification

• Breaking change: the support for TensorFlow has been dropped; the
  classifier CGAL::TensorFlow::Neural_network_classifier has been removed.

CGAL-5.2.2 is a bug-fix release.

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

CGAL-5.1.4 is a bug-fix release.

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

CGAL-5.2.1 is a bug-fix release.

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

CGAL-5.1.3 is a bug-fix release.

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

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

Fixes, improvements, and various small features have been added since CGAL 5.1. See https://www.cgal.org/2020/12/22/cgal52/ for a complete list of changes.

CGAL-5.1.2 is a bug-fix release.

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

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

CGAL version 5.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 5.2 in December 2020.

Fixes, improvements, and various small features have been added since CGAL 5.1. See https://www.cgal.org/2020/11/18/cgal52-beta1/ for a complete list of changes.

CGAL-5.1.1 is a bug-fix release.

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

CGAL-5.0.4 is a bug-fix release.

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

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

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.

  See also the associated blog entry.

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.

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.

Installation

• The CGAL_Core library no longer requires Boost.Thread, even if the g++ compiler is used.
• The minimal supported version of Boost is now 1.66.0.

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.

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/09/08/cgal51/ for a complete list of changes.

CGAL-5.0.3 is a bug-fix release.

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

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.

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.

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.

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 Open Source Project is pleased to announce the release 5.1 Beta 1 of CGAL, the Computational Geometry Algorithms Library.

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.1 in July.

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.

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.

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.

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/06/09/cgal51-beta1 for a complete list of changes.

CGAL-5.0.2 is a bug-fix release.

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

CGAL-4.14.3 is a bug-fix release. In particular, it fixes a performance regression in the 3D Triangulations, when the Parallel_tag is used.

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

CGAL-5.0.1 is a bug-fix release. In particular, it fixes a performance regression in the 3D Triangulations, when the Parallel_tag is used.

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

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

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

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.

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.

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

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.
  (See also the new entry in the User Manual)

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/11/08/cgal50/ for a complete list of changes.