Release History
Release 5.6
Release date: June 2023
General Changes
- Breaking change: The per package assertions, pre- and postconditions are no longer supported.
2D and 3D Linear Geometry Kernel
- Added the functor
CompareAngle_3
to the conceptKernel
to compare an angle defined by three points to the cosinus of another angle.
Combinatorial Maps Generalized Maps 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 toCGAL::Tag_true
in the item class.
Linear Cell Complex
- Added the class
Linear_cell_complex_incremental_builder_3
.
Polygon Mesh Processing
-
Breaking change: Deprecated the overloads of functions
CGAL::Polygon_mesh_processing::triangulate_hole()
,CGAL::Polygon_mesh_processing::triangulate_and_refine_hole()
, andCGAL::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. -
added functions
CGAL::Polygon_mesh_processing::region_growing_of_planes_on_faces()
andCGAL::Polygon_mesh_processing::detect_corners_of_regions()
that allow to have a partition into planar regions of a mesh using the region growing algorithm from the Shape Detection package. -
Added the function
CGAL::Polygon_mesh_processing::surface_Delaunay_remeshing()
, that remeshes a surface triangle mesh following the CGAL tetrahedral Delaunay refinement algorithm. -
Added the function
CGAL::Polygon_mesh_processing::surface_Delaunay_remeshing()
, that remeshes 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()
to remove badly shaped triangles faces in a mesh. -
Added the function
CGAL::Polygon_mesh_processing::triangulate_polygons()
, which allows users to triangulate polygon soups. -
Added the functions
CGAL::Polygon_mesh_processing::remesh_planar_patches()
andCGAL::Polygon_mesh_processing::remesh_almost_coplanar_patches()
to retriangulate patches of coplanar faces in a mesh. -
Added a named parameter to
CGAL::Polygon_mesh_processing::smooth_shape()
to disable scaling to compensate volume loss. -
Added the functions
CGAL::Polygon_mesh_processing::does_triangle_soup_self_intersect()
andCGAL::Polygon_mesh_processing::triangle_soup_self_intersections()
to identify and report self-intersections in a triangle soup, similarly to existing functions on triangle meshes.
3D Simplicial Mesh Data Structure (new package)
- This new package wraps all the existing code that deals with a
MeshComplex_3InTriangulation_3
to describe 3D simplicial meshes, and makes the data structure independent from the tetrahedral mesh generation package.
Shape Detection (breaking change, major changes)
- Breaking change: The region growing part of the package have been reworked to fix design issues introduced with the handling
FaceGraph
models. In particular, the notion ofItem
has been introduced to reference an element in the input range of elements. Region maps now operates onItem
and no longer on the value type of the input range. - Breaking change: The method
update()
in the conceptRegionType
returns now aboolean
instead ofvoid
that is used inside the classRegion_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
Polyline_graph
class 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 Arrangements
- Fixed some code that handles geodesic-curves on spheres that compare x- and y-coordinates on the boundary of the parameter space. It mainly effected the naive point-location.
- Introduced an overload function template, namely
draw(arr)
, that renders arrangements based on theBasic_viewer_qt
class template. At this point 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:- Fixed a couple of bugs and slightly optimized some functions.
- Introduced functionality that approximates conics with polylines. (This is used to draw conic curves.)
- 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.)
2D Convex Hulls
- Breaking change: The concept
ConvexHullTraits_2
no longer requires the functorLess_signed_distance_to_line_2
, but requires the functorCompare_signed_distance_to_line_2
instead. - The long-deprecated classes
Convex_hull_projective_xy_traits_2
,Convex_hull_projective_xz_traits_2
, andConvex_hull_projective_yz_traits_2
have been removed. Users should useProjection_traits_xy_3
,Projection_traits_xz_3
, andProjection_traits_yz_3
instead.
2D Triangulations
- Added function
mark_domains_in_triangulation()
to mark faces connected with non constrained edges as inside of the domain based on the nesting level.
2D Conforming Triangulations and Meshes
- Deprecated usage of boost parameters in favor of function named parameters in
CGAL::lloyd_optimize_mesh_2()
. - Deprecated two overloads of Function
refine_Delaunay_mesh()
and replaced them with versions using function named parameters. - Add overloads of function
write_VTU()
with property maps for specifying the domain.
3D Mesh Generation
- Deprecated usage of boost parameters in favor of function named parameters.
- 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 the prescribed size bound. - Added new meshing criteria
facet_min_size
andcell_min_size
to prevent Delaunay refinement from creating simplices smaller than the prescribed bound.
3D Periodic Mesh Generation
- Periodic Mesh Generation now supports non-cubic domains.
- Deprecated usage of boost parameters in favor of function named parameters.
2D Hyperbolic Triangulations
- Breaking change: the concept
HyperbolicTriangulationFaceBase_2
has been modified to better reflect the triangulation's requirements and avoid a conflict with the requirements described by the conceptTriangulationDataStructure_2::Face
. The modelCGAL::Hyperbolic_triangulation_face_base_2
has been adapted correspondingly.
Surface Mesh Simplification
- The stop predicates
Count_stop_predicate
andCount_ratio_stop_predicate
are renamed toEdge_count_stop_predicate
andEdge_count_ratio_stop_predicate
. Older versions have been deprecated. - Introduce
Face_count_stop_predicate
andFace_count_ratio_stop_predicate
that can be used to stop the simplification algorithm based on a desired number of faces in the output, or a ratio between input and output face numbers.
2D Minkowski Sums
- Fixed a bug that made holes in the Minkowski sum disappear
- Fixed hole filtering. The code used to erroneously remove holes from the container of holes of polygons with holes that did not affect the minkowsi sum. Now it simply adds those that do affect it.
2D Straight Skeleton and Polygon Offsetting (breaking change) (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.
2D Regularized Boolean Set Operations
- Exposed all required member functions of the
GeneralPolygonWithHoles_2
concept (e.g.,clear_outer_boundary()
,clear_holes()
, andclear()
).
Polygon
- Fixed the function
draw(const CGAL::Polygon_with_holes_2<T, C>& pwh, const char* title)
to enable the correct drawing of unbounded polygons with holes.
Release 5.5
Release date: June 2022
3D Alpha Wrapping (new package)
-
This component takes a 3D triangle mesh, soup, or point set as input, and generates a valid (watertight, intersection-free, and combinatorially 2-manifold) surface triangle mesh that contains the input. The algorithm proceeds by shrink-wrapping and refining a 3D 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 surface mesh 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 announcement page.
2D Straight Skeleton and Polygon Offsetting (breaking change)
- Fix the output of the function CGAL::create_exterior_skeleton_and_offset_polygons_with_holes_2() to not take into account the offset of the outer frame.
- Fix the computation of the exterior offset of a polygon with holes that was not computing the offset of the holes
3D Convex Hulls
- Added an overload of the function
CGAL::convex_hull_3()
, which writes the result in an indexed triangle set.
2D Polygons
- Add vertex, edge, and hole ranges.
- The concept
GeneralPolygonWithHoles_2
now requires the nested typePolygon_2
instead ofGeneral_polygon_2
.
2D Regularized Boolean Set-Operations
- The concept
GeneralPolygonSetTraits_2
now requires the nested typeConstruct_polygon_with_holes_2
instead ofConstruct_general_polygon_with_holes_2
.
Combinatorial Maps
- Removed old code deprecated in CGAL 4.9 and 4.10 (global functions, and information associated with darts).
2D Arrangements
- Fixed the
intersect_2
,compare_y_at_x_right
, andcompare_y_at_x_left
function objects of the traits class templateArr_geodesic_arc_on_sphere_traits_2
that handles geodesic arcs on sphere and applied a small syntactical fix to the tracing traits.
Tetrahedral Mesh Generation
- Added the function
remove_isolated_vertices()
as a post-processing step for the tetrahedral mesh generation.
Polygon Mesh Processing
- Added the function
CGAL::Polygon_mesh_processing::orient_triangle_soup_with_reference_triangle_soup()
, which enables re-orienting the faces of a triangle soup based on the orientation of the nearest face in a reference triangle soup. - Added the function
CGAL::Polygon_mesh_processing::compatible_orientations()
, which enables to retrieve the (in)compatibility of orientations of faces from different connected components. - Added the function
CGAL::Polygon_mesh_processing::tangential_relaxation()
, which applies an area-based tangential mesh smoothing to the vertices of a surface triangle mesh. - Added the named parameter
visitor
to the functiontriangulate_hole()
, which enables to track progress with callbacks. - Added more functions in the visitor of the corefinement based methods to track progress.
Surface Mesh Simplification
- Introduced four variations of the Garland-Heckbert simplification algorithm based on the probabilistic approach of Trettner and Kobbelt (Fast and Robust QEF Minimization using Probabilistic Quadrics):
GarlandHeckbert_plane_policies
,GarlandHeckbert_probabilistic_plane_policies
,GarlandHeckbert_triangle_policies
, andGarlandHeckbert_probabilistic_triangle_policies
. - The class
GarlandHeckbert_policies
has been deprecated,GarlandHeckbert_plane_policies
replaces it.
Point Set Processing
- A new optional named parameter,
min_points_per_cell
has been added togrid_simplify_point_set()
. By adding a minimal number of points in a cell such that a point is retained, one can also filter out low density areas and outliers: in the case of densely sampled point clouds, this yields better results than using grid simplification and then outlier removal, while being very vast. The default value is1
to keep the previous behavior as default.
dD Spatial Searching
- Added the member function
write_graphviz()
to the classKd_tree
that writes the tree in a stream in the Graphviz format.
CGAL and the Boost Graph Library (BGL)
- Added the function
invert_selection()
in the classFace_filtered_graph
, which toggles the selected status of a graph: selected faces are deselected, and unselected faces are selected.
Release 5.4
Release date: January 2022
General changes
-
Added the cmake target
CGAL::CGAL_Basic_viewer
to ease the compilation of programs using the basic viewer-based functionCGAL::draw()
. This target will define the macro and link withCGAL_Qt5
target when linked with it. -
The kernel providing exact constructions and exact predicates (
CGAL::Exact_predicates_exact_constructions_kernel
) is now thread-safe. See changes in2D and 3D Linear Geometry Kernel
for more details. -
The class
Geomview_stream
and all the dependent features have been removed from CGAL. Those features were actually no longer supported since CGAL-5.3 but it was not properly announced.
Shape Regularization (new package)
- This package enables to regularize a set of segments and open or closed contours in 2D and a set of planes in 3D such that all input objects are rotated and aligned with respect to the user-specified conditions. In addition, it provides a global regularization framework that can be adjusted for the user needs and any type of geometric objects.
Weights (new package)
- This package provides a simple and unified interface to different types of weights. In particular, it groups all weights into three category: analytic weights including all basic weights which can be computed analytically for a query point with respect to its local neighbors in 2D and 3D; barycentric weights, including all weights which can be computed for a query point with respect to the vertices of a planar polygon; and weighting regions, including all weights which are used to balance other weights.
2D Generalized Barycentric Coordinates (major changes)
- Breaking change: The headers
Segment_coordinates_2.h
andTriangle_coordinates_2.h
are renamed tosegment_coordinates_2.h
andtriangle_coordinates_2.h
. - The classes
Segment_coordinates_2
andTriangle_coordinates_2
are deprecated. The free functionscompute_segment_coordinates_2()
andcompute_triangle_coordinates_2()
are deprecated as well. Instead, the free functionssegment_coordinates_2()
andtriangle_coordinates_2()
should be used. - The enums
Query_point_location
andType_of_algorithm
are deprecated. Instead, the enumComputation_policy_2
should be used. - The classes
Wachspress_2
,Discrete_harmonic_2
,Mean_value_2
, andGeneralized_barycentric_coordinates_2
are deprecated. As consequence, the conceptBarycentricCoordinates_2
is deprecated as well. Instead, the classesWachspress_coordinates_2
,Discrete_harmonic_coordinates_2
, andMean_value_coordinates_2
should be used. - Added the class
Harmonic_coordinates_2
to compute approximate harmonic coordinates in 2D. These coordinates satisfy all properties of barycentric coordinates inside any simple polygon. - Added a new concept
DiscretizedDomain_2
and a model of this concept calledDelaunay_domain_2
, which is based on the Mesh 2 package. A model of this concept is required to useHarmonic_coordinates_2
. - Added free functions to compute Wachspress, discrete harmonic, and mean value coordinates.
- All free functions and classes are now using ranges and property maps.
2D and 3D Linear Geometry Kernel
-
Most operations on
CGAL::Exact_predicates_exact_constructions_kernel
objects are now thread-safe ifCGAL::Exact_rational
ismpq_class
(fromGMPXX
),boost::multiprecision::mpq_rational
orCGAL::Quotient<CGAL::MP_Float>
. The objects are not atomic though, so the usual restrictions on avoiding race conditions apply. For users who do not use threads, this can be disabled withCGAL_HAS_NO_THREADS
. -
Added documentation for the class
Projection_traits_3
, which enables the use of 2D algorithms on the projections of 3D data onto an arbitrary plane. -
Added
construct_centroid_2_object()
andcompute_determinant_2_object()
inProjection_traits_xy_3
,Projection_traits_xz_3
, andProjection_traits_yz_3
classes. -
Added the functor
NonZeroCoordinateIndex_3
to the conceptKernel
withint operator()(Vector_3)
which returns the index of any coordinate of the vector different from zero, or-1
.
dD Kernel
- Most operations on
Epeck_d
objects are now thread-safe, see 2D and 3D Linear Geometry Kernel for details.
2D Arrangements
-
Breaking Change: The traits function objects
Compare_x_at_limit_2
andCompare_x_near_limit_2
are renamed toCompare_x_on_boundary_2
andCompare_x_near_boundary_2
, respectively. -
A new hierarchy of traits concepts has been introduced. It captures all the valid combinations of boundary conditions for the 4 boundary sides of the parameter space. The 4 boundaries are Bottom, Top, Left, and Right. Each boundary side can be either contracted, identified, close, open, or oblivious. Not all possible combinations are valid. If one side is identified then the other must be as well. Two adjacent sides cannot be contracted.
-
A new geometric traits,
Arr_geodesic_arc_on_sphere_traits_2
has been introduced. It handles arcs of great circles embedded on the unit sphere.
2D Regularized Boolean Set-Operations
- Added an extra parameter (
UsePolylines
) to all free functions (complement()
,do_intersect()
,intersection()
,join()
,difference()
,symmetric_difference()
, andoriented_side
) to control whether to useArr_polyline_traits_2
as default traits. It is the new default as it provides better performances in general.
3D Mesh Generation
- Added support of weighted images for an improved quality of meshes generated from labeled images,
along with a function
CGAL::Mesh_3::generate_label_weights()
to generate the weights.
Polygon Mesh Processing
-
Added the function
CGAL::Polygon_mesh_processing::match_faces()
, which, given two polygon meshes, identifies their common faces as well as faces present in only either of them. -
Added the functions:
CGAL::Polygon_mesh_processing::bounded_error_Hausdorff_distance()
that computes an estimate of the one-sided Hausdorff distance between two triangle meshes which is bounded by a user-specified error bound;CGAL::Polygon_mesh_processing::bounded_error_symmetric_Hausdorff_distance()
that computes an estimate of the symmetric Hausdorff distance bounded by a user-specified error bound; andCGAL::Polygon_mesh_processing::is_Hausdorff_distance_larger()
that returnstrue
if the bounded-error Hausdorff distance between two meshes is larger than the user-specified max distance. -
Added the functions
CGAL::Polygon_mesh_processing::squared_edge_length()
andCGAL::Polygon_mesh_processing::squared_face_area()
, which, compared toCGAL::Polygon_mesh_processing::edge_length()
andCGAL::Polygon_mesh_processing::face_area()
, enable avoiding square-root operations. -
Added more functions in the visitor of the corefinement based methods to track all vertex creations.
-
Added an option to
CGAL::Polygon_mesh_processing::self_intersections()
to report only a limited number of intersections (maximum_number()
).
The Heat Method
- Breaking change: Added the functor
Compute_squared_length_3
providingoperator(const Vector_3& v)
, which computes the squared length ofv
, to theHeatMethodTraits_3
concept.
Point Set Processing
- Added support for
libpointmatcher::GenericDescriptorOutlierFilter
that enables providing a map from a point to a weight associated with this point.
Shape Detection
- Added new shapes to the Region Growing algorithm on a point set: circles in 2D, spheres in 3D, and cylinders in 3D.
CGAL and Solvers
- Added support for the OSQP solver. This solver enables to efficiently compute the convex Quadratic Programming (QP) problems arising in the context of several packages.
Release 5.3
Release date: July 2021
General changes
-
The support for the compiled version of CGAL is dropped. Only the header-only version is supported.
-
On Windows, the type used for
CGAL::Exact_rational
, inEpick
and indirectly (throughLazy_exact_nt
)Epeck
may now beboost::multiprecision::mpq_rational
, as has been the case on other platforms for several releases. This depends on various options and is added to a list that includesmpq_class
,CGAL::Gmpq
,leda_rational
andCGAL::Quotient<CGAL::MP_Float>
.
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()
, andis_rotation()
to the classesAff_transformation_2
andAff_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 whether a closed path on a surface mesh can be continuously 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 classCGAL::Regular_triangulation
, which enables users to insert a pointp
in a regular triangulation on the condition thatp
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
, andWeighted_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.
Release 5.2
Release date: December 2020
dD Geometry Kernel
- The kernels
Epick_d
andEpeck_d
gain two new functors:Compute_power_product_d
andConstruct_power_sphere_d
, to deal with weighted points.
CGAL and the Boost Graph Library (BGL)
- Added a convenience header,
CGAL/boost/graph/graph_traits_inheritance_macros.h
, which enables easily making any class inheriting from a model of a face graph concept, a model of the same concept. - Added the function
can_add_face()
, which tests whether a new face defined by a range of vertices can be added.
3D Fast Intersection and Distance Computation (AABB Tree)
- Added the move constructor and the assignment operator to the AABB Tree class.
2D Arrangements
- Replaced the use of legacy
CGAL::Object
to modernboost::variant
. - Changed make-x-monotone return type from legacy
CGAL::Object
toboost::variant
in all traits concepts and models. As there exists an implicit conversion fromboost::variant
toCGAL::Object
, the new code is backward compatible. However, it is recommended that all calls to the make-x-monotone functions are fixed to use the new return type. - Changed
decompose()
interface to useboost::variant
instead of legacyCGAL::Object
As explained above, the code is backward compatible. However, it is recommended that all calls todecompose()
are fixed to use the new interface.
Surface Mesh
- Added the function
clear_without_removing_property_maps()
to clear a mesh but keep all the created property maps added. - Added the functions
remove_property_maps<Index_type>()
andremove_all_property_maps()
to remove all added property maps by index type or all of them respectively. - Added the functions
set_recycle_garbage()
anddoes_recycle_garbage()
to the classSurface_mesh
.
Polygon Mesh Processing
- Added a visitor to the functions
CGAL::Polygon_mesh_processing::triangulate_face()
andCGAL::Polygon_mesh_processing::triangulate_faces()
, that enables the user to keep track of the newly created faces through the triangulation process. - Added an option in
CGAL::Polygon_mesh_processing::corefine()
,CGAL::Polygon_mesh_processing::split()
andCGAL::Polygon_mesh_processing::clip()
functions, which enable the operations to be performed on a mesh with self-intersections present in the intersection area. - Added an optional range parameter to
CGAL::Polygon_mesh_processing::stitch_borders()
, which can be used to specify which boundary cycles are eligible for stitching.
Surface Mesh Parameterization
- Added a new parameterization method, Iterative Authalic Parameterization. It is based on the work of Jain, Hardik, Manuel Wollhaf, and Olaf Hellwich, "Learning to Reconstruct Symmetric Shapes using Planar Parameterization of 3D Surface." (IEEE International Conference on Computer Vision Workshops, 2019).
Classification
-
Breaking change: new IO format for the
ETHZ::Random_Forest
classifier: a conversion function from the outdated format to the new one is provided. -
Added new functions to the class
CGAL::Classification::Evaluation
:append()
to enrich the evaluation with additional results;confusion()
to access the confusion matrix; output functions to save the evaluation to andASCII
orHTML
stream. -
Added a new operator,
CGAL::Classification::feature_cast<>
, for easy conversions. -
The classes
CGAL::Classification::Feature_set
andCGAL::Classification::Label_set
are now models of the conceptRange
. -
The class
CGAL::Classification::Label
now has attributesindex
,standard_index
andcolor
, with automatic selection if the ASPRS standard names are used. -
Added new functions in
CGAL::Classification::Point_set_feature_iterator
, to enable users to select which features should be generated. -
Added a new function,
CGAL::Classification::Label_set::is_valid_ground_truth()
, to help users check if a ground truth matches a given label set.
Point Set Processing
- Added a function
CGAL::scanline_orient_normals()
, which orients a point cloud by estimating a line of sight.
3D Convex Hulls
- Added the function
CGAL::halfspace_intersection_interior_point_3()
, which can be used to retrieve the point that is the most interior a convex closed volume defined by the intersection of a set of halfspaces.
3D Triangulations
- Added new classes and functions to visit the cells and simplices intersected by a line segment, see Sections Segment Cell Iterator and Segment Simplex Iterator, respectively.
Release 5.1
Release date: September 2020
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.
2D and 3D Linear Geometry Kernel
- Added the functor
CompareSignedDistanceToLine_2
to the 2D/3DKernel
concept to compare the signed distance of two points to a line, or the line passing through two given points. Corresponding functors in the model (Compare_signed_distance_to_line_2
) are also added.
dD Geometry Kernel
- The kernels
Epick_d
andEpeck_d
gain two new functors:Power_side_of_bounded_power_sphere_d
andCompute_squared_radius_smallest_orthogonal_sphere_d
. Those are essential for the computation of weighted alpha-complexes.
Surface Mesh
- Breaking change: The function
CGAL::Surface_mesh::clear()
now removes all non-default properties instead of just emptying them.
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. - Added the function
CGAL::set_triangulation_ids()
, which must be used to initialize vertex, edge, and face indices of a triangulation meant to be used with BGL algorithms.
3D Fast Intersection and Distance Computation (AABB Tree)
- 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 callingCGAL::AABB_tree::accelerate_distance_queries()
. - Breaking change:
CGAL::AABB_tree::accelerate_distance_queries()
andCGAL::AABB_tree::do_not_accelerate_distance_queries()
are no longerconst
functions.
2D Arrangements
- Changed intersection return type from legacy
CGAL::Object
to modernboost::variant
in all traits concepts and models. As there exists an implicit conversion fromboost::variant
toCGAL::Object
, the new code is backward compatible. However, it is recommended that all calls to the intersection functions are fixed to use the new return type.
2D Regularized Boolean Set-Operations
- Changed intersection return type from legacy
CGAL::Object
to modernboost::variant
in the conceptArrDirectionalTraits::Intersect_2
and its models.
2D Minkowski Sums
- Changed intersection return type from legacy
CGAL::Object
to modernboost::variant
in the (internally used) modelArr_labeled_traits_2
.
dD Spatial Searching
- The kd-tree can now be built in parallel:
CGAL::Kd_tree::build()
is given an optional template parameterConcurrencyTag
(default value remainsCGAL::Sequential_tag
for backward compatibility). - Improved the performance of the kd-tree in some cases:
- Not storing the points coordinates inside the tree usually
generates a lot of cache misses, leading to non-optimal
performance. This is the case for example
when indices are stored inside the tree, or to a lesser extent when the points
coordinates are stored in a dynamically allocated array (e.g.,
Epick_d
with dynamic dimension) — we says "to a lesser extent" because the points are re-created by the kd-tree in a cache-friendly order after its construction, so the coordinates are more likely to be stored in a near-optimal order on the heap. In these cases, the newEnablePointsCache
template parameter of theCGAL::Kd_tree
class can be set toCGAL::Tag_true
. The points coordinates will then be cached in an optimal way. This will increase memory consumption but provides better search performance. See the updatedGeneralDistance
andFuzzyQueryItem
concepts for additional requirements when using such a cache. - In most cases (e.g., Euclidean distance), the distance computation algorithm knows before its end that the distance will be greater than or equal to some given value. This is used in the (orthogonal) k-NN search to interrupt some distance computations before its end, saving precious milliseconds, in particular in medium-to-high dimension.
- Not storing the points coordinates inside the tree usually
generates a lot of cache misses, leading to non-optimal
performance. This is the case for example
when indices are stored inside the tree, or to a lesser extent when the points
coordinates are stored in a dynamically allocated array (e.g.,
Intersecting Sequences of dD Iso-oriented Boxes
- Added parallel versions of the functions
CGAL::box_intersection_d()
andCGAL::box_self_intersection_d()
.
Spatial Sorting
- Added parallel versions of the functions
CGAL::hilbert_sort()
andCGAL::spatial_sort()
in 2D and 3D when the median policy is used. The parallel versions use up to four threads in 2D, and up to eight threads in 3D.
3D Convex Hulls
- A new overload for
CGAL::convex_hull_3()
that takes a model ofVertexListGraph
has been added. - The long-deprecated function
CGAL::convex_hull_3_to_polyhedron_3()
has been removed. The functionCGAL::convex_hull_3_to_face_graph()
should be used instead.
Polygon Mesh Processing
- Added the function
CGAL::Polygon_mesh_processing::volume_connected_component()
, which can be used to get information about the nesting of the connected components of a given triangle mesh and about the volumes defined. - Added the function
CGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size()
, which can be used to remove connected components whose area or volume is under a certain threshold. Area and volume thresholds are either specified by the user or deduced from the bounding box of the mesh. - Added a new named parameter for
CGAL::Polygon_mesh_processing::keep_large_connected_components()
andCGAL::Polygon_mesh_processing::remove_connected_components_of_negligible_size
, which can be used to perform a dry run of the operation, meaning that the function will return the number of connected components that would be removed with the specified threshold, but without actually removing them. - 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 the functions
CGAL::Polygon_mesh_processing::merge_reversible_connected_components()
,CGAL::Polygon_mesh_processing::duplicate_non_manifold_edges_in_polygon_soup()
, andCGAL::Polygon_mesh_processing::orient_triangle_soup_with_reference_triangle_mesh()
, which can be helpful when repairing a polygon soup. - Added the function
CGAL::Polygon_mesh_processing::sample_triangle_soup()
, which generates points on a triangle soup surface. - Added parallel versions of the functions
CGAL::Polygon_mesh_processing::does_self_intersect()
andCGAL::Polygon_mesh_processing::self_intersections()
. - The function
CGAL::Polygon_mesh_processing::stitch_borders()
now returns the number of halfedge pairs that were stitched. - Added the function
CGAL::Polygon_mesh_processing::polygon_mesh_to_polygon_soup()
. - The function
CGAL::Polygon_mesh_processing::polygon_soup_to_polygon_mesh
now allows passing a point map (for the point range) and a vertex point map (for the polygon mesh) via named parameters.
Point Set Processing
- Breaking change:
CGAL::remove_outliers()
has been parallelized and thus has a new template parameterConcurrencyTag
. To update your code simply add as first template parameterCGAL::Sequential_tag
orCGAL::Parallel_tag
when calling this function. - Add a function
CGAL::cluster_point_set()
that segments a point cloud into connected components based on a distance threshold. - Added wrapper functions for registration:
CGAL::OpenGR::compute_registration_transformation()
, which computes the registration transformation for two point sets using the Super4PCS algorithm implemented in the third party library OpenGR.CGAL::OpenGR::register_point_sets()
, which computes the registration transformation for two point sets using the Super4PCS algorithm implemented in the third party library OpenGR, and registers the points sets by transforming the data point set using the computed transformation.CGAL::pointmatcher::compute_registration_transformation()
computes the registration transformation for two point sets using ICP algorithm implemented in the third party library libpointmatcher.CGAL::pointmatcher::register_point_sets()
, which computes the registration transformation for two point sets using ICP algorithm implemented in the third party library libpointmatcher, and registers the points sets by transforming the data point set using the computed transformation.
2D Triangulations
- To fix an inconsistency between code and documentation and to clarify which types of intersections
are truly allowed in constrained Delaunay triangulations, the tag
CGAL::No_intersection_tag
has been deprecated in favor of two new tags:CGAL::No_constraint_intersection_tag
andCGAL::No_constraint_intersection_requiring_constructions_tag
. The latter is equivalent to the now-deprecatedCGAL::No_intersection_tag
, and allows constraints to intersect as long as no new point has to be created to represent that intersection (for example, the intersection of two constraint segments in a 'T'-like junction is an existing point and as such does not require any new construction). The former tag,CGAL::No_constraint_intersection_tag
, does not allow any intersection, except for the configuration of two constraints having a single common endpoints, for convenience. - Added the function
CGAL::split_subconstraint_graph_into_constraints()
toConstrained_triangulation_plus_2
to initialize the constraints from a soup of disconnected segments that should first be split into polylines.
3D Triangulations
- The member function
CGAL::Triangulation_3::file_input()
have been added. It allows to load aCGAL::Triangulation_3
from an input stream, using functors to create vertices and cells.
3D Triangulation Data Structure
- The member function
CGAL::TDS_3::file_input()
have been added. It allows to load aCGAL::Triangulation_data_structure_3
from an input stream, using functors to create vertices and cells.
Surface Mesh Simplification
- Added a new simplification method based on the quadric error defined by Garland and Heckbert.
- The concept
EdgeProfile
has been removed. This concept was not actually in use as the CGAL-provided modelCGAL::Edge_profile
was imposed to the user. Other concepts have been clarified to reflect the fact that the API uses this particular class.
STL Extensions for CGAL
- Added a new concurrency tag:
CGAL::Parallel_if_available_tag
. This tag is a convenience typedef toCGAL::Parallel_tag
if the third party library TBB has been found and linked with, and toCGAL::Sequential_tag
otherwise.
Release 5.0
Release date: November 2019
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 toEfficientRANSACTraits
. - Breaking change: The
Shape_detection_3
namespace has been renamed toShape_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 Linear Geometry Kernel
- Added a new concept,
ComputeApproximateAngle_3
, to the 3D Kernel concepts to compute the approximate angle between two 3D vectors. Corresponding functors in the model (Compute_approximate_angle_3
) and free function (approximate_angle
) have also been added. - The following objects are now hashable and thus trivially usable
with
std::unordered_set
andstd::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
andCGAL::Weighted_point_3
.
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) - 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()
andCGAL::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()
andCGAL::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 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.
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 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
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()
andCGAL::remove_outliers()
.
2D Triangulations
- Breaking change: Removed the deprecated functions
CGAL::Constrained_triangulation_plus_2:: vertices_in_constraint_{begin/end}(Vertex_handle va, Vertex_handle vb) const;
, andCGAL::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 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 visible 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
). - Breaking change: The
insert()
function ofCGAL::Triangulation_2
which takes a range of points as argument is now guaranteed to insert the points following the order ofInputIterator
. Note that this change only affects the base classTriangulation_2
and not any derived class, such asDelaunay_triangulation_2
. - Added a new constructor
and
insert()
function toCGAL::Triangulation_2
that takes a range of points with info. - 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. - 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 for a usage demonstration.
3D Triangulations
- Breaking change: The constructor
and the
insert()
function ofCGAL::Triangulation_3
which take a range of points as argument are now guaranteed to insert the points following the order ofInputIterator
. Note that this change only affects the base classTriangulation_3
and not any derived class, such asDelaunay_triangulation_3
. - Added constructor and
insert()
function toCGAL::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 for a usage demonstration.
Surface Mesh
- Introduced new functions to read and write using the PLY format,
CGAL::read_ply()
andCGAL::write_ply()
, enabling users to save and load additional property maps of the surface mesh.
CGAL and Solvers
- Added concepts and models for solving Mixed Integer Programming (MIP) problems with or without constraints.
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()
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_WKT()
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()
Release 4.14
Release date: March 2019
2D Periodic Hyperbolic Triangulations (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.
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.
The Heat Method (new package)
- 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)
- This package implements the Variational Shape Approximation method to approximate an input surface triangle mesh by a simpler surface triangle mesh.
Polygon Mesh Processing package
-
Added the following new functions to detect and repair issues in polygon soups:
CGAL::Polygon_mesh_processing::remove_isolated_points_in_polygon_soup()
, which detects and removes points that are not used in any polygon of the soup.CGAL::Polygon_mesh_processing::merge_duplicate_points_in_polygon_soup()
, which detects and merges points that share the same geometric position.CGAL::Polygon_mesh_processing::merge_duplicate_polygons_in_polygon_soup()
, which detects and merges polygons that are identical.CGAL::Polygon_mesh_processing::repair_polygon_soup()
, which applies a number of repairing steps (a subset of which are the functions above) to clean and repair a polygon soup.
-
Added the following new functions to detect and repair degeneracies in polygon meshes:
CGAL::Polygon_mesh_processing::degenerate_edges()
CGAL::Polygon_mesh_processing::degenerate_faces()
CGAL::Polygon_mesh_processing::is_non_manifold_vertex()
CGAL::Polygon_mesh_processing::is_degenerate_triangle_face()
CGAL::Polygon_mesh_processing::is_degenerate_edge()
CGAL::Polygon_mesh_processing::is_needle_triangle_face()
CGAL::Polygon_mesh_processing::is_cap_triangle_face()
CGAL::Polygon_mesh_processing::duplicate_non_manifold_vertices()
CGAL::Polygon_mesh_processing::extract_boundary_cycles()
CGAL::Polygon_mesh_processing::merge_duplicated_vertices_in_boundary_cycle()
CGAL::Polygon_mesh_processing::merge_duplicated_vertices_in_boundary_cycles()
-
Added the class
CGAL::Rigid_triangle_mesh_collision_detection
to detect intersections between meshes and volumes undergoing affine transformations.
Regularized Boolean Set Operations in 2D package
- Fixed the validation of orientation of relative simple polygons.
Point Set Processing
CGAL::mst_orient_normals()
can now be called with a set of user-selected seed points that are known to be already oriented. A new optional named parameterpoint_is_constrained_map
is added for this purpose. The original behavior (using one unique and automatically selected seed) is kept if this parameter is not used.
Classification
-
Added a new experimental classifier
TensorFlow::Neural_network_classifier
. -
For uniformity,
ETHZ_random_forest_classifier
is renamedETHZ::Random_forest_classifier
andOpenCV_random_forest_classifier
is renamedOpenCV::Random_forest_classifier
. -
The training algorithm of
ETHZ::Random_forest_classifier
was parallelized. -
Added a constructor to copy a
ETHZ::Random_forest_classifier
using a different data set as input. -
Added 3 new geometric features,
Height_above
,Height_below
andVertical_range
.
3D Fast Intersection and Distance Computation
- The primitives
AABB_face_graph_triangle_primitive
andAABB_halfedge_graph_segment_primitive
now use asId
a pair of descriptor and graph pointer in the case they are configured to deal with a possible different graph per primitive (configuration set using a template tag).
2D Arrangements
-
Fixed a bug in the surface-sweep framework (
Surface_sweep_2
) that ensures that an event is never left without (left or right) curves. -
Fixed a constructor of
Arr_counting_traits.h
. (In particular, added missing const of a parameter). -
Fixed zone computation of a curve in cases where the lexicographic smallest end of the curve lies on the parameter space.
-
Implemented missing function object
Compare_x_near_boundary
ofArr_polyline_traits_2
,Arr_polycurve_traits_2
, andArr_polycurve_basic_traits_2
.
2D and 3D Mesh Generation
- Added two functions for writing in XML VTK formats:
CGAL::write_vtu()
, that writes a 2D mesh in a.vtu
file,CGAL::output_to_vtu()
, that writes a 3D mesh in a.vtu
file.
2D Minkowski Sums
- Fixed a bug in the function that computed the Minkowski sum using the reduced-convolution method. In particular, correctly handled the case where one of the summands does not have an outer boundary.
3D Point Set
-
Added a method
copy_properties()
that allows to copy the properties from a point set to another one (without copying the content); -
Added a method
insert(const Point_set&, const Index&)
to copy a point along with all its associated properties from another point set; -
remove()
methods now only invalidate theend()
iterator instead of invalidating all iterators; -
Added a method
is_removed()
that takes an index as argument; -
Added a method
cancel_removals()
to restore removed points (if no point was inserted since then an garbage was not collected); -
Breaking change: unified API of method
add_normal_map()
withadd_property_map()
: it now returns a pair of property map + bool (that tells if the property was added) instead of just the property map; -
Added a method
properties_and_types()
in addition toproperties()
: this new one returns pairs ofstd::string
+std::type_info
in order to also know the type of each property.
CGAL and the Boost Graph Library (BGL)
- Added function
write_wrl()
for writing into VRML 2.0 format. - Added functions
CGAL::write_vtp()
for writing a triangulated face graph in a.vtp
file (XML VTK format).
Release 4.13
Release date: October 2018
3D Periodic Mesh Generation (new package)
- This package generates 3-dimensional periodic meshes. It computes isotropic simplicial meshes for domains described through implicit functional boundaries over the flat torus (which can also seen in the Euclidean space as a periodic cube). The output is a periodic 3D mesh of the domain volume and conformal surface meshes for all the boundary and subdividing surfaces. The package is closely related to the 3D Mesh Generation package, with similar concepts, classes, and API.
Installation
- The library
CGAL_Qt5
now contains a fork of the version 2.7.0 oflibQGLViewer
. The corresponding code is in the packageGraphicsView
. The dependency for the external librarylibQGLViewer
is therefore dropped for all demos.
General
- A new function
CGAL::draw()
is added in the packages Polyhedral Surface, Surface Mesh, Linear Cell Complex, 2D Triangulations, and 3D Triangulations, enabling to draw the corresponding data structures.
2D and 3D Linear Geometry Kernel
- An
operator()
that takes aRay_3
has been added to the conceptConstructProjectedPoint_3
.
Convex hull 3
-
Added the function
extreme_points_3()
computing the points on the convex hull without underlying connectivity. -
Added a traits adapter called
Extreme_points_traits_adapter_3
that enables the use of the functionextreme_points_3()
on a range of keys, each key being associated to 3D point using a property map. This can be used to get the vertices of a mesh that are on it convex hull, or the indices of points in a range that are on it convex hull. -
Fix a bug in the computation of the 3D convex hull that was leaving extra points within subset of coplanar points that do not belong to the minimal convex hull.
2D and 3D Triangulations
-
Added a new type of intersection to handle the insertion of intersecting constraints in a
Constrained_triangulation_2
. -
Breaking change: The long-deprecated class
Triangulation_cell_base_with_circumcenter_3
and its associated concept have been removed. Users should use the classesDelaunay_cell_base_with_circumcenter_3
orRegular_cell_base_with_circumcenter_3
, depending on which type of triangulation they are using. -
Breaking change: The deprecated functions
mirror_index
andmirror_vertex
of the classTriangulation_face_base_2
have been removed. Users should use the equivalent functions from the classTriangulation_2
.
3D Mesh Generation
-
Breaking change: The template parameters of the class template
Labeled_mesh_domain_3
have been simplified. The three constructors of that class template have been replaced by a new unique constructor using Boost named parameters. Three new static template member functions that act as named constructors have been added:create_gray_image_mesh_domain()
, to create a domain from a 3D gray image,create_labeled_image_mesh_domain()
, to create a domain from a 3D labeled image, andcreate_implicit_mesh_domain()
, to create a domain from an implicit function.
-
The class templates
Implicit_mesh_domain_3
,Gray_image_mesh_domain_3
, andLabeled_image_mesh_domain_3
are now deprecated. -
Breaking change: The headers
<CGAL/Mesh_3/Implicit_to_labeled_function_wrapper.h>
and<CGAL/Mesh_3/Labeled_mesh_domain_3.h>
, that were deprecated since CGAL 4.5, have been removed. -
Breaking change: the concepts
MeshCellCriteria_3
andMeshFacetCriteria_3
now require the triangulation to be passed in theiroperator()
. Models of these concepts that are provided by CGAL have been modified accordingly. -
Breaking change: It is no longer possible to use the deprecated, pre-CGAL 3.8 specifications in
MeshCellCriteria_3
andMeshFacetCriteria_3
(that is, usingFacet_badness
andCell_badness
instead ofIs_facet_bad
andIs_cell_bad
). -
The concept
MeshFacetCriteria_3
no longer requires the functionoperator()(Cell_handle c, int i)
. -
The concept
MeshEdgeCriteria_3
no longer requires the functionoperator()(const Edge& e)
. -
The concept
MeshComplexWithFeatures_3InTriangulation_3
no longer requires the functionsnumber_of_edges(Curve_index index)
andnumber_of_corners(Corner_index index)
. -
Introduced the concept
MeshTriangulationTraits_3
, which covers the needs of the traits class used inMesh_3
(andPeriodic_3_mesh_3
). The traits class used as template parameter ofMesh_triangulation_3
andPeriodic_3_mesh_triangulation_3
must be a model of this concept. -
Added the function
Mesh_domain_with_polyline_features_3::add_corner()
, which allows users to add a single corner (that is not incident to any polyline) to the mesh complex. -
Breaking change:
CGAL::lloyd_optimize_mesh_3
now depends on the Eigen library.
Polygon Mesh Processing
-
Added a named parameter in stitching functions that allows to choose whether the operation should be performed per connected component or globally.
-
Added a function,
CGAL::Polygon_mesh_processing::transform()
, to apply a transformation to a mesh. -
Added a named parameter
visitor
in corefinement-related functions that makes it possible to pass a visitor to the function in order to track the creation of new faces. -
Added a named parameter
throw_on_self_intersection
in all corefinement-related functions, which enables to check for self-intersecting faces involved in the intersection before trying to corefine the input meshes. This new parameter replaces thebool
parameter incorefine()
. -
Added the function
corefine_and_compute_boolean_operations()
, which can be used to compute the result of several Boolean operations between two volumes at the same time. -
Added the function
clip()
, which can be used to clip a triangulated surface mesh by a plane or a clipping volume. -
Constrained vertices are now guaranteed to be kept in the mesh after calling
isotropic_remeshing()
(and not only the points associated to constrained vertices, as it was before). -
Added a function,
CGAL::Polygon_mesh_processing::extrude_mesh()
, to perform an extrusion of an open polygon mesh.
Estimation of Local Differential Properties of Point-Sampled Surfaces Reference
- Breaking change:
CGAL::Monge_via_jet_fitting
now depends on the Eigen library.
Point Set Processing
- Added a callback mechanism to the following functions:
CGAL::bilateral_smooth_point_set()
,CGAL::compute_average_spacing()
,CGAL::grid_simplify_point_set()
,CGAL::hierarchy_simplify_point_set()
,CGAL::jet_estimate_normals()
,CGAL::jet_smooth_point_set()
,CGAL::pca_estimate_normals()
,CGAL::remove_outliers()
andCGAL::wlop_simplify_and_regularize_point_set()
.
Classification
-
Added data structures to handle classification of Surface Meshes and of Clusters.
-
Added public API to compute features in parallel.
-
Breaking change: features based on products/divisions of eigenvalues are replaced by simple eigenvalue features. Features based on statistics on the HSV color channels are replaced by simple HSV color channel features.
-
Breaking change: the API of
CGAL::Classification::Point_set_feature_generator
has been simplified.
Bounding Volumes
- Breaking change:
CGAL::Approximate_min_ellipsoid_d
now depends on the Eigen library.
Interpolation
-
The output of the natural and regular neighbor functions (resp. the gradient fitting functions) is no longer restricted to a Point/Coordinate pair (resp. Point/Vector pair). Instead, users can provide their own functor to format the output as they desire.
-
The interpolation functions can now operate on any combination of Type/Coordinate, provided that the values and gradients functors can also be evaluated using 'Type'.
The combination of these two changes allow, for example, to operate with Vertex/Coordinate pairs, which enables a more efficient access to values and gradients by storing information directly in the vertex.
-
The concepts
InterpolationTraits
andGradientFittingTraits
have been updated to reflect the real needs of the code (some types and operators were used in the code but did not appear in the concepts).
CGAL and the Boost Graph Library (BGL)
-
Added a helper function,
CGAL::is_valid_polygon_mesh
, that checks the validity of a polygon mesh using BGL functions. -
Improved the function
CGAL::Euler::collapse_edge
such that the target vertex of the collapsed edge is now always kept after the collapse. -
The function
copy_face_graph()
now uses named parameters, some allowing it to use property maps instead of output iterators. -
Addition of the following named parameters :
- vertex_to_vertex_output_iterator
- halfedge_to_halfedge_output_iterator
- face_to_face_output_iterator
- vertex_to_vertex_map
- halfedge_to_halfedge_map
- face_to_face_map
CGAL and Solvers
- Breaking change:
CGAL::Diagonalize_traits
is now deprecated and should not be used. The classCGAL::Eigen_diagonalize_traits
(along with the Eigen library) should be used instead.
CGAL and Boost Property Maps
- Added a read-write property map to convert on-the-fly geometric objects from Cartesian kernels.
2D Arrangements
-
Refracted and fixed the
graph_traits
for the dual of an arrangement of the following types:Arrangement_on_surface_2
,Arrangement_2
,Arrangement_on_surface_with_history_2
, andArrangement_with_history_2
. -
Breaking change: The old
<CGAL/graph_traits_Dual_Arrangement_2.h>
header file has been replaced by the four header files below; each defines thegraph_traits
for dual of the corresponding arrangement type.<CGAL/graph_traits_dual_arrangement_on_surface_2.h>
,<CGAL/graph_traits_dual_arrangement_2.h>
,<CGAL/graph_traits_dual_arrangement_on_surface_with_history_2.h>
, and<CGAL/graph_traits_dual_arrangement_with_history_2.h
.
Release 4.12
Release date: April 2018
Important Notice
-
The CMake scripts used by CGAL have been changed to use modern patterns introduced by CMake 2.8.12 and CMake 3.0: instead of setting CMake variables, the script now defines imported targets and uses link interfaces.
That is mostly backward-compatible with existing usages of CGAL CMake scripts. The only non-compatible effect is that the
CMAKE_BUILD_TYPE
and compilation flags are no longer copied from theCGAL_DIR
to the project using it. Note also that theCMAKE_BUILD_TYPE
is no longer set toRelease
by default. For a developer using the Visual Studio IDE or the Xcode IDE, the change should be transparent. Developers using makefiles or the Ninja build-system should set theCMAKE_BUILD_TYPE
toRelease
manually, to avoid using CGAL libraries without any compile-time optimization.
Header-only Mode
- Since CGAL-4.9, it has been possible to use CGAL by configuring it using CMake, but without compiling the CGAL libraries. With CGAL-4.12, it is now possible to use CGAL header-only, without even configuring it. CMake is then used only to configure programs using CGAL.
Compiler Support
-
The Microsoft Visual C++ 2017 version 15.3 has introduced support for C++17, with the compilation flag
/std:c++17
. CGAL 4.12 has an initial support for that flag: the code will compile, but a lot of deprecation warnings will remain. Note that Boost version 1.67 is the first version of Boost supporting/std:c++17
. -
The compilation flag
/permissive-
of Visual C++ is now supported.
2D Movable Separability of Sets (new package)
-
A new package called "2D Movable Separability of Sets" has been introduced. It handles a class of problems that deal with moving sets of objects in the plane; the challenge is to avoid collisions between the objects while considering different kinds of motions and various definitions of separation.
At this point this package consists of the implementations of various predicates and constructions related to castings of polygonal objects. In particular, it can be used to determine whether a feasible mold for a polygonal object does exist. If a mold exists, the package can also be used to compute all possible orientations of the feasible molds and the corresponding motions needed to remove the casted object from the mold.
Classification (new package)
- This package offers an algorithm that classifies a data set into a user-defined set of labels (such as ground, vegetation, buildings, etc.). A flexible API is provided so that users can classify any type of data, compute their own local features on the input data set, and define their own labels.
Kinetic Data Structures (removed package)
- This package has been removed from CGAL-4.12. Users of the package will have to keep using the source code available in CGAL-4.11 or earlier.
3D Convex Hull
- Breaking change: The header
<CGAL/convex_hull_3.h>
no longer includes<CGAL/Polyhedron_3.h>
, as the convex hull function works with any model of the conceptMutableFaceGraph
.
2D Arrangements
-
When removing an edge from an arrangement and the user has requested to remove the end-vertices in case they become redundant (either isolated or approach infinity), defer the removal of the such end-vertices to occur after the observer is notified that the edge has been removed. This is symmetric (opposite) to the order of notification when an edge is inserted.
The user can restore old (non-symmetric) behaviour by defining the macro:
CGAL_NON_SYMETRICAL_OBSERVER_EDGE_REMOVAL_BACKWARD_COMPATIBILITY
2D Periodic Triangulations
- Breaking change: The class
Periodic_2_triangulation_hierarchy_vertex_base_2
(and its corresponding header) have been removed. Users should directly use the classTriangulation_hierarchy_vertex_base_2
, which is identical. - Breaking change: The functions
circumcenter()
,side_of_oriented_circle()
, andis_extensible_in_1_sheet_h[12]()
are related to Delaunay triangulations and have been moved fromPeriodic_2_triangulation_2
toPeriodic_2_Delaunay_triangulation_2
.
2D Alpha Shapes
- It is now possible to use
CGAL::Periodic_2_triangulation_2
as underlying triangulation forAlpha_shape_2
.
3D Surface Mesh Generation
- Add the function
facets_in_complex_2_to_triangle_mesh()
that exportsSurface_mesh_complex_2_in_triangulation_3
facets into aMutableFaceGraph
.
3D Mesh Generation
- Add the function
facets_in_complex_3_to_triangle_mesh()
that exportsMesh_complex_3_in_triangulation_3
facets into aMutableFaceGraph
. - Breaking change: The concept
MeshDomainWithFeatures_3
has been modified, to improve the performance and the reliability of the sampling of 1D curves of the domain. - Add the ability to ensure that the output mesh surface describes a
manifold, when the input surface is a manifold. New named parameters
manifold()
,manifold_with_boundary()
, andnon_manifold()
are added.
Optimal Transportation Curve Reconstruction
- New method
run_under_wasserstein_tolerance()
which allows the user to perform curve reconstruction by relying on a threshold on the Wasserstein distance. This is useful when the number of edges in the expected output reconstruction is not known.
Polygon Mesh Processing
-
Added two functions for orienting connected components :
CGAL::Polygon_mesh_processing::orient()
CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()
-
Added a new function for intersection tests between triangle meshes and/or polylines or range of polylines, and another one to report all the pairs of meshes intersecting from a range of meshes:
CGAL::Polygon_mesh_processing::do_intersect()
CGAL::Polygon_mesh_processing::intersecting_meshes()
-
Added new functions for feature detection and feature-guided segmentation:
CGAL::Polygon_mesh_processing::detect_sharp_edges()
CGAL::Polygon_mesh_processing::detect_vertex_incident_patches()
CGAL::Polygon_mesh_processing::sharp_edges_segmentation()
Point Set Shape Detection
- Breaking change:
CGAL::Shape_detection_3::Efficient_RANSAC_traits
is now calledCGAL::Shape_detection_3::Shape_detection_traits
. - New algorithm:
CGAL::Region_growing
. This is a deterministic alternative to RANSAC for plane detection. - Breaking change: the API of
CGAL::regularize_planes()
is generalized to accept other types of input than the RANSAC output. - Add a callback mechanism for both
CGAL::Efficient_RANSAC
andCGAL::Region_growing
.
Point Set Processing
- Breaking change: the API of
CGAL::structure_point_set()
is generalized to accept other types of input than the RANSAC output. - Breaking change: the API of all functions of Point Set Processing is modified to use ranges (instead of iterators) and Named Parameters (similarly to the API of Polygon Mesh Processing). The old API is kept as deprecated.
CGAL and the Boost Graph Library (BGL)
-
Add helper function
CGAL::expand_face_selection_for_removal
that expands a face selection to avoid creating a non manifold mesh when removing the selected faces. -
Added support for dynamic property maps.
-
Added an interface to the METIS library, which allows to partition any mesh that is a model of
FaceListGraph
. Wrappers to the METIS functionsMETIS_PartMeshNodal
andMETIS_PartMeshDual
are offered.
Release 4.11
Release date: September 2017
3D Periodic Regular Triangulations (new feature)
- Added the class
Periodic_3_regular_triangulation_3
, which provides functionality for 3D periodic weighted Delaunay triangulations. The construction is fully dynamic: it provides both point insertion and vertex removal.
dD Regular Triangulations (new feature)
- Added the class
Regular_triangulation
, which provides functionality for dD weighted Delaunay triangulations. Note that the removal of points is not yet supported.
2D and 3D Linear Geometry Kernel (breaking change)
- Breaking change: The dangerous implicit conversions between
weighted points and points in the concept
Kernel
have been disabled. Constructors offering to build a weighted point from a point (and reversely) are still requested by the conceptKernel
but must now be marked with theexplicit
specifier. - Breaking change: The removal of implicit conversions between
points and weighted points in the concept
Kernel
has incidentally created various minor breaking changes in the following packages: 2D Alpha Shapes, 2D and 3D Triangulations, and 3D Mesh Generation. See the full changelog for details.
Surface Mesh
- Breaking change:
operator >>(std::istream&, Surface_mesh&)
no longer clears the surface mesh.
Triangulated Surface Mesh Parameterization (breaking change)
- Breaking change: The package has been rewritten and can operate
on any model of the
MutableFaceGraph
concept. All previous parameterization methods are still offered, although with a different, simpler API. The documentation has been updated and offers a gentle introduction to the new API. Users who wish to use the former API must use a version prior to 4.11. - Breaking change: The adapter to add virtual seams is now the
class
CGAL::Seam_mesh
in the package CGAL and the BGL. - Breaking change: The package has been restructured and most
headers have been moved. In a general manner, users should replace
<CGAL/XXX.h>
with<CGAL/Surface_mesh_parameterization/XXX.h>
- Add the As Rigid As Possible Parameterization method. This parameterization allows the user to prioritize angle preservation, shape preservation, or a balance of both.
- Add the Orbifold Tutte Embedding method. This parameterization method allows to parameterize meshes that are topological spheres.
3D Surface Subdivision Methods (breaking changes)
- The subdivision algorithms now work on any model of a
MutableFaceGraph
. A new API to the subdivision methods is offered, which uses optional named parameters to pass the number of iterations and a vertex property map. - Breaking change: Removed the headers
<CGAL/Subdivision_method_3.h>
and<CGAL/Subdivision_mask_3.h>
. The headers<CGAL/Subdivision_method_3/subdivision_methods_3.h>
and<CGAL/Subdivision_method_3/subdivision_masks_3.h>
should respectively be used instead. - Sqrt3 subdivision can now handle input surfaces with a border.
Scale-Space Surface Reconstruction (breaking change)
- Breaking change: the API was rewritten to separate the smoothing
and meshing algorithm and making it possible for the user to use
different ones. The default algorithms used are the same as before
this API change, but methods are moved to the classes
Weighted_PCA_smoother
andAlpha_shape_mesher
. - Alternative smoothing and meshing methods are provided:
Jet_smoother
andAdvancing_front_mesher
.
2D Alpha Shapes
- Breaking change: Mirrored the concepts of the 2D alpha shape
package with those of the 3D Alpha Shapes package. Consequently, a
new concept,
WeightedAlphaShapeTraits_2
, is introduced to provide requirements on the traits class for 2D weighted alpha shapes. All models of the conceptKernel
are models of this new concept. - The concept
AlphaShapeTraits_2
now provides requirements on the traits class for 2D basic alpha shapes, and refinesDelaunayTriangulationTraits_2
.
Interpolation
- Breaking change: The concept
GradientFittingTraits
now additionally requests a weighted point typeWeighted_point_d
and a functorConstruct_point_d
. The modelCGAL::Interpolation_gradient_fitting_traits_2
has been appropriately modified to still be a model of the conceptGradientFittingTraits
.
2D and 3D Triangulations
- Breaking change: Added a new functor requirement,
Construct_point_2
, to the conceptsTriangulationTraits_2
andRegularTriangulationTraits_2
and a new functor requirement,Construct_point_3
, to the conceptsTriangulationTraits_3
andRegularTriangulationTraits_3
. All models of the conceptKernel
already provide these functors. - Breaking change: Introduced the concepts
RegularTriangulationVertexBase_2
andRegularTriangulationVertexBase_3
. These concepts describe the requirements on classes meant to represent a vertex of a regular triangulation. Concepts that previously refinedTriangulationVertexBase_2
orTriangulationVertexBase_3
but described in fact a vertex class used in a regular triangulation, such as the conceptMeshVertexBase_3
in the 3D mesh generation package, now refine the corresponding new regular vertex concept. - Breaking change: Uniformized the point type across all vertex
and cell concepts. The triangulation point type name is now always
Point
. Note that this does not change the requirements but only the name:Point
is still expected to be equal toTraits::Point_[23]
for basic and Delaunay triangulations or toTraits::Weighted_point_[23]
for regular triangulations. Consequently:- The concept
RegularTriangulationVertexBase_2
now requests aPoint
type (equal toTraits::Weighted_point_2
) - The concept
RegularTriangulationCellBase_3
now requests aPoint
type instead of aWeighted_point
type (but still equal toTraits::Weighted_point_3
) - The concept
DelaunayTriangulationCellBase_3
now requests aPoint
type instead of aPoint_3
type (but still equal toTraits::Point_3
).
- The concept
- Introduced a new concept,
RegularTriangulationCellBaseWithWeightedCircumcenter_3
, which describes the requirements on a cell of a regular triangulation that caches its circumcenter. The existing classRegular_triangulation_cell_base_with_weighted_circumcenter_3
is the default model of this concept. - Added a new 3D traits class,
Robust_weighted_circumcenter_filtered_traits_3
which provides robust versions of the kernel functorsConstruct_weighted_circumcenter_3
,Compute_squared_radius_3
, andCompute_squared_radius_smallest_orthogonal_sphere_3
. This class can be used as traits class in theMesh_3
package to efficiently yet robustly generate 3D meshes. - Add a new type of polyhedral domain with features,
Polyhedral_complex_mesh_domain_3
. The domain is defined by a collection of triangulated surfaces, forming a complex.
3D Periodic Triangulations
- Added new locate and geometric access functions for 3D periodic triangulations.
- The class
Periodic_3_Delaunay_triangulation_traits_3
now inheritsPeriodic_3_triangulation_traits_3
. - Breaking change: Some geometric access functions in
Periodic_3_triangulation_3
were renamed. The introduction ofPeriodic_3_regular_triangulation_3
required to distinguish between functions such assegment()
returning a segment of weightless points, or a segment of weighted points. As a general rule, previous geometrical access functions will return objects with point type that of the triangulation (thus, weighted objects when using weighted triangulations) and functions containingconstruct
in the name will always return weightless geometrical objects. - Breaking change: The concept
Periodic_3TriangulationTraits_3
now requests a domain getter:get_domain()
. - Introduced a new concept,
RegularTriangulationCellBaseWithWeightedCircumcenter_3
, which describes the requirements on a cell of a regular triangulation that caches its circumcenter. The existing classRegular_triangulation_cell_base_with_weighted_circumcenter_3
is the default model of this concept.
3D Mesh Generation
- Breaking change: The type of the surface center in the concept
MeshCellBase_3
has been changed fromTriangulation::Point
toTriangulationTraits::Point_3
to reflect that it is a weightless point. - Breaking change: The function
invalidate_circumcenter()
of the conceptMeshCellBase_3
is renamed toinvalidate_weighted_circumcenter_cache()
and moved to the new conceptRegularTriangulationCellBaseWithWeightedCircumcenter_3
, which the conceptMeshCellBase_3
now refines.
Poisson Surface Reconstruction
- A new global function
CGAL::poisson_surface_reconstruction_delaunay()
is provided in addition to the current class-based API in order to make it easier to use.
Point Set Processing
- New functions to read from and write to LAS/LAZ files (LIDAR format), with or without taking additional properties into account.
- Breaking change: The API of the PLY function to read points with
properties is modified for unification with LAS (see
CGAL::read_ply_points_with_properties()
). A new function to write PLY with properties is provided (CGAL::write_ply_points_with_properties()
).
Spatial Searching
- Add function
Kd_tree::remove(Point)
.
3D Fast Intersection and Distance Computation
- Add a template parameter to
AABB_traits
for a property map that associates a bounding box to a primitive
CGAL and the Boost Graph Library
- Add a partial specialization for the class
CGAL::Linear_cell_complex_for_combinatorial_map
so that it is a model of the graph conceptsBidirectionalGraph
andEdgeAndVertexListGraph
and of the conceptMutableFaceGraph
. This class can thus now be used in all BGL functions and algorithms. - Helper functions to create an icosahedron, a regular prism and a pyramid have been added.
- Add class
CGAL::Face_filtered_graph
that wraps an existing graph and hide all simplices that are not in the selected connected components. - Added the class
CGAL::Seam_mesh
. TheSeam_mesh
is a graph adaptor which allows to create virtual borders when marking edges as seam edges. - Add the functions
read_off()
andwrite_off()
.
Release 4.10
Release date: May 2017
Installation
- The minimum required version of CMake is now 3.1. All CMake versions up to 3.7 are supported.
- The compilation of some demo may require a C++11 compiler. The CGAL library itself still support C++03 compilers.
- The shell script
cgal_create_cmake_script
now enables C++14 by default. - A new mechanism to check which packages of CGAL are used have been added. It is particularly interesting for commercial users to ensure they have a valid commercial license for the packages they used. This can also be used to make sure only LGPL header files are used.
- Because of a bug in the g++ compiler about the C++11 keyword
thread_local
, the CGAL_Core library now always requiresBoost.Thread
if the g++ compiler is used.
Generalized Maps (new package)
- This package implements Generalized Maps in d dimensions. A generalized map is a data structure enabling to represent an orientable or non orientable subdivided object by describing all the cells of the subdivision (for example in 3D vertices, edges, faces, volumes) and all the incidence and adjacency relationships between these cells. This data structure is the generalization of the combinatorial maps in order to be able to represent non orientable objects.
3D Point Set (new package)
- This package provides a flexible data structure
CGAL::Point_set_3
that allows the user to easily handle point sets with an arbitrary number of attributes (such as normal vectors, colors, labeling, etc.).
Combinatorial Maps and Linear cell complex
- Breaking change: the requirements of the item class used to
customize a combinatorial map and a linear cell complex changed.
Instead of defining the type of darts used, you have to define the
information you want to add in each dart. You can define the
CGAL_CMAP_DART_DEPRECATED
macro to keep the old behavior.
Triangulated Surface Mesh Shortest Paths
- Breaking change: Rename all functions, types, and enums using barycentric coordinate to barycentric coordinates.
CGAL and the Boost Graph Library (BGL)
- Breaking change: Addition of a free function
reserve()
in the conceptMutableFaceGraph
. Models provided by CGAL have been updated.
2D and 3D Linear Geometry Kernel
- Breaking change: The function
compare_slopes()
was renamedcompare_slope
. - Added a 2D and 3D weighted point class and predicates and constructions.
- Add functions
l_infinity_distance()
for 2D and 3D. - Add a new functor in CGAL Kernel concept to compare the slope of two
3D segments. All models of the Kernel concept now provide the
functor
Compare_slope_3
, and the free functioncompare_slope()
is available. - Add an operator in CGAL Kernel concept
Angle_3
to qualify the angle between the normal of the triangle given by three points, and a vector.
3D Convex Hull
- The convex hull function can also produce a
Surface_mesh
, and generally speaking any model of the conceptMutableFaceGraph
- The function
convex_hull_3_to_polyhedron_3()
is deprecated andconvex_hull_3_to_face_graph.h
should be used instead. - The class
Convex_hull_traits_3
now documents a nested typePolygon_mesh
instead ofPolyhedron_3
. The other nested type is kept for backward compatibility. - Remove the function
CGAL::convex_hull_incremental_3()
deprecated since CGAL 4.6.
3D Boolean Operations on Nef Polyhedra
- Add a new constructor from a face graph model
Linear cell complex
- Deprecate class
Linear_cell_complex
which is now renamedLinear_cell_complex_for_combinatorial_map_dart
.
2D Triangulation data structure
- Add function
insert_in_hole
.
2D Triangulations
- Breaking change: Removed the arbitrary dimensional weighted point class. Users must use a version prior to 4.9 if they need this class.
- Breaking change:The number type of weighted points in regular triangulations is no longer a template parameter but the field type of the geometric traits class. Users who need this feature must use a version prior to 4.9
- The class
Regular_triangulation_filtered_traits_2
deprecated since CGAL 3.6 has been removed. - Deprecate the class
Regular_triangulation_euclidean_traits_2
, as the weighted point and the function objects for weighted points are part of the conceptKernel
/ - The class
Regular_triangulation_2
can take a kernel as template argument, that is one no longer has to useRegular_triangulation_euclidea_traits_2
, although this still works.
3D Triangulations
- Breaking change: The number type of weighted points in regular triangulations is no longer a template parameter but the field type of the geometric traits class. Users who need this feature must use a version prior to 4.9.
- The class
Regular_triangulation_filtered_traits_3
deprecated since CGAL 3.6 has been removed. - Deprecate the class
Regular_triangulation_euclidean_traits_3
, as the weighted point and the function objects for weighted points are part of the conceptKernel
/ - The class
Regular_triangulation_3
can take a kernel as template argument, that is one no longer has to useRegular_triangulation_euclidean_traits_3
, although this still works. - Add function
link_to_face_graph()
to copy the set of faces incident to a vertex into a model ofFaceGraph
.
3D Mesh Generation
- The constructor
CGAL::Polyhedral_mesh_domain_with_features_3(std::string)
is deprecated.
Polygon Mesh Processing
- Add fast and robust corefinement and Boolean operation functions for
triangulated surface meshes:
CGAL::Polygon_mesh_processing::corefine_and_compute_union()
CGAL::Polygon_mesh_processing::corefine_and_compute_difference()
CGAL::Polygon_mesh_processing::corefine_and_compute_intersection()
CGAL::Polygon_mesh_processing::corefine()
CGAL::Polygon_mesh_processing::does_bound_a_volume()
CGAL::Polygon_mesh_processing::surface_intersection()
- Add functions to compute approximated Hausdorff distances between
two meshes, a mesh and a point set, or a point set and a mesh:
sample_triangle_mesh()
,approximated_Hausdorff_distance()
,approximated_symmetric_Hausdorff_distance()
,max_distance_to_triangle_mesh()
,max_distance_to_point_set()
. - The function
CGAL::Polygon_mesh_processing::bbox_3()
has been renamedCGAL::Polygon_mesh_processing::bbox()
.
Point Set Processing
- Function
CGAL::remove_outliers()
has an additional parameter based on a distance threshold to make it easier and more intuitive to use. - New functions for automatic scale estimations: either a global scale or multiple local scales can be estimated for both 2D and 3D point sets based on the assumption that they sample a curve in 2D or a surface in 3D.
CGAL and the Boost Graph Library (BGL)
- Add function
CGAL::convert_nef_polyhedron_to_polygon_mesh()
to convert aNef_polyhedron_3
to any model of theMutableFaceGraph
concept. - Add class
CGAL::Graph_with_descriptor_with_graph
that wraps an existing graph and provides a reference to the said graph to all of its descriptors.
Cone Based Spanners
- Add a parameter to compute half Tao graph and half Theta graph.
- Add an ipelet for this package.
Geometric Object Generators
- Add point random generators
- in a 3D triangle mesh model of the concept
FaceListGraph
(CGAL::Random_points_in_triangle_mesh_3
), - on the boundary of a tetrahedral mesh
(
CGAL::Random_points_in_tetrahedral_mesh_boundary_3
), - in a tetrahedral mesh
(
CGAL::Random_points_in_tetrahedral_mesh_3
), - in a 2D triangle mesh
(
CGAL::Random_points_in_triangle_mesh_2
), - in a range of 2D or 3D triangles
(
CGAL::Random_points_in_triangles_3
andCGAL::Random_points_in_triangles_2
). - on a 3D segment (
CGAL::Random_points_on_segment_3
).
- in a 3D triangle mesh model of the concept
Release 4.9
Release date: Sept 2016
Header-only mode
- CGAL can now be used in headers only mode, i.e. without compiling the CGAL libraries and linking with these libraries when compiling examples, tests and demos. Note that running CMake on CGAL is still required in order to generate some configuration files.
Cone Based Spanners (new package)
- This package provides algorithms for constructing two kinds of cone-based spanners: Yao graph and Theta graph, given a set of vertices on the plane and the directions of cone boundaries.
2D Minkowski Sums
- Introduce a convex decomposition strategy, namely
Polygon_nop_decomposition_2
, that merely passed the input polygon to the list of output polygons. - Introduce overloads of the function
minkowski_sum_2()
, which accepts 2 decomposition strategies. - Introduce an overloaded function called
minkowski_sum_by_decomposition_2(P, Q, decom_no_holes, decomp_with_holes)
, which computes the 2D Minkowski sum using optimal choices of decomposition strategies.
Combinatorial Maps
- Deprecate global functions (
make_combinatorial_hexahedron()
,make_combinatorial_polygon()
,make_combinatorial_tetrahedron()
,make_edge()
,insert_cell_0_in_cell_1()
,insert_cell_0_in_cell_2()
,insert_cell_1_in_cell_2()
,insert_cell_2_in_cell_3()
,insert_dangling_cell_1_in_cell_2()
,is_insertable_cell_1_in_cell_2()
,is_insertable_cell_2_in_cell_3()
,is_removable()
,remove_cell()
) which are now member functions in theCombinatorialMap
concept. - It is not longer possible to use the old API switched on by defining
the macro
CGAL_CMAP_DEPRECATED
. This API was deprecated since CGAL 4.4.
Point Set Processing
- New function
CGAL::read_ply_custom_points()
that allows the user to read any additional point attribute from a PLY input point set. CGAL::structure_point_set()
: new algorithm that takes advantage of detected planes to produce a structured point set (with flat regions, sharp edges and vertices).
Point Set Shape Detection
- New post-processing algorithm:
CGAL::regularize_planes()
. This allows the user to favor parallelism, orthogonality, coplanarity and/or axial symmetry between detected planes.
Polygon Mesh Processing
- Add the function
CGAL::Polygon_mesh_processing::is_polygon_soup_a_polygon_mesh()
to check whether a polygon soup is a polygon mesh. - Add some new features to
CGAL::isotropic_remeshing()
:- It is now possible to select fixed vertices that survive the remeshing process, and to keep face attributes such as colors valid after remeshing.
- The user can choose the number of relaxation steps happening at each loop, and to run 1-dimensional relaxation along constrained polylines.
- The functions
CGAL::Polygon_mesh_processing::triangulate_face()
andCGAL::Polygon_mesh_processing::triangulate_faces()
now indicate whether some faces have not been triangulated.
Surface Mesh Deformation
- Add a new tag
SRE_ARAP
to use the Smoothed Rotation Enhanced As-Rigid-As-Possible deformation algorithm.
3D Fast Intersection and Distance Computation
- Add the functions
AABB_tree::first_intersection()
andAABB_tree::first_intersected_primitive()
that compute the intersection which is closest to the source of a ray
CGAL and the Boost Graph Library (BGL)
- Add a helper function
CGAL::copy_face_graph()
to copy a source FaceListGraph into another FaceListGraph of different type. - Add a class
CGAL::Dual
that creates the dual view of aFaceGraph
and a creation functionCGAL::dual(primal)
.
CGAL and Boost Property Maps
- It is not longer possible to use the old API of the property maps
provided by CGAL, switched on by defining the macro
CGAL_USE_PROPERTY_MAPS_API_V1
. This API was deprecated since CGAL 4.3.
Release 4.8
Release date: April 2016
General
- The support for Qt3 is dropped and all demos using it got removed.
Installation
- Starting with Visual C++ 2015 we no longer require
Boost.Thread
as we use the C++11 keywordthread_local
and the C+11 classstd::mutex
. - The same holds for g++ 4.8 or later when the C++11 standard is used.
Optimal Transportation Curve Reconstruction (new package)
- This package implements a method to reconstruct and simplify 2D point sets. The input is a set of 2D points with mass attributes, possibly hampered by noise and outliers. The output is a set of line segments and isolated points which approximate the input points.
2D Regularized Boolean Set-Operations
- Improve the performance of operations in some settings.
Breaking change: This improvement requires changes of the face
and halfedge type of the underlying arrangement Dcel. See the
concepts
GeneralPolygonSetDcelHalfedge
andGeneralPolygonSetDcelFace
for more details. If you use a different simplex types, inheriting your simplices fromCGAL::Gps_face_base
andCGAL::Gps_halfedge_base
is sufficient to accommodate for the update.
3D Boolean Operations on Nef Polyhedra
- Add 3 new constructors: from a point range, from a point, and from a segment.
Combinatorial Maps
- Breaking change: Change the type of Boolean marks, old type is
int, new type is
size_type
. If no more mark is available,get_new_mark
throws an exception, instead of returning-1
.
2D Arrangements
- Speed up the edge removal in case the incident faces contains many holes.
- Set the format of polylines and polycurves. The format of a general polyline or polycurve consists of the sequence of subcurves that comprise the original curve. The format of a polyline of linear segments consists of the sequence of points that define the original curve. (The latter restores the format used before polycurves were introduced in 4.7.) Fix the extraction from istream and insertion into ostream operators of polylines and polycurves accordingly.
- Fix the traits class that handles Bezier curves. In particular, fix the case where the curve is closed (i.e, the first and last control points coincide).
3D Mesh Generation
- Add support of 3D gray level images as input for the tetrahedral mesh generation.
- Breaking change: All models of the concept
MeshDomain_3
must now provide a member functionbbox()
.
Advancing Front Surface Reconstruction
- Optional template functor
Filter
is replaced by another optional template functorPriority
. This allows to change the way facets are prioritized by the algorithm instead of having a simple option to reject some facets. Breaking change: Programs using the oldFilter
API will not compile anymore as it must be replaced with thePriority
API as described in the manual. Codes using the default behavior are not impacted.
Polygon Mesh Processing
- Add a new triangle-based isotropic remeshing algorithm for
triangulated surface meshes,
CGAL::Polygon_mesh_processing::isotropic_remeshing()
and a helper function for isotropic remeshing :CGAL::Polygon_mesh_processing::split_long_edges()
- Add the function
CGAL::Polygon_mesh_processing::border_halfedges()
to collect the border of a given face range - Add the function
CGAL::Polygon_mesh_processing::remove_isolated_vertices()
to be used on any polygon mesh - Add the function
CGAL::Polygon_mesh_processing::triangulate_face()
to triangulate a single face of a polygon mesh - Add an overload for
CGAL::Polygon_mesh_processing::triangulate_faces()
to triangulate a range of faces of a polygon mesh - Add function
keep_large_connected_components()
- Add measuring functions for polygon meshes, to compute length, area, and volume of simplices or group of simplices of a polygon mesh.
- Add function
bbox_3()
to compute the bounding box of a polygon mesh.
Point Set Processing
- Breaking change: new template parameter
Concurrency_tag
for the functionscompute_average_spacing()
,edge_aware_upsample_point_set()
,jet_estimate_normals()
,jet_smooth_point_set()
, andpca_estimate_normals()
. To update your code simply add as first template parameterCGAL::Sequential_tag
orCGAL::Parallel_tag
when calling one of these functions. CGAL::Parallel_tag
can no longer be used in Point Set Processing algorithms if TBB is not available.- Add a new simplification algorithm based on hierarchical clustering:
CGAL::hierarchy_simplify_point_set()
. It allows either to uniformly simplify the point set or to automatically adapt the local density of points to the local variation of the input computed by principal component analysis. - New IO functions for PLY format (Polygon File Format):
CGAL::read_ply_points()
,CGAL::read_ply_points_and_normals()
,CGAL::write_ply_points()
andCGAL::write_ply_points_and_normals()
.
Surface Mesh Parameterization
LSCM_parameterizer_3
now uses by default Eigen instead of OpenNL as a model ofSparseLinearAlgebraTraits_d
.
Spatial Searching
- Add function to find any point in a range query, that is neither all points, nor the closest one.
Principal Component Analysis
- Add a template parameter
DiagonalizeTraits
for functionsCGAL::linear_least_squares_fitting_2()
andCGAL::linear_least_squares_fitting_3()
. This allows to either choose the legacy internal diagonalization code from CGAL or the Eigen implementation (or any class that is a model ofDiagonalizeTraits
). Variants of the function that automatically deduce the kernel also automatically select the diagonalizer, so the API is mostly preserved.
CGAL and Solvers
- This package now includes all CGAL concepts for solvers with models using the third party Eigen library.
CGAL and the Boost Graph Library (BGL)
- Add function
CGAL::split_graph_into_polylines()
that allows to extract from a soup of segments given as a graph, polylines with nodes of degree at most 2. In addition a functor can be passed to the function to specify additional polyline endpoints. - New functions to manipulate selection of faces, edges and vertices
in a halfedge graph are added:
CGAL::expand_face_selection()
,CGAL::reduce_face_selection()
,CGAL::expand_edge_selection()
,CGAL::reduce_edge_selection()
CGAL::expand_vertex_selection()
,CGAL::reduce_vertex_selection()
andCGAL::select_incident_faces()
. - Add a helper function
CGAL::clear
which clears a MutableFaceGraph efficiently and generically.
Release 4.7
Release date: October 2015
Installation
- The minimum required version of CMake is now 2.8.11. CMake versions 3.1, 3.2, and 3.3 are supported.
- All Qt4 demos have been updated and now require Qt5 to be compiled.
Qt5 version 5.3 or higher is required. The support for Qt4 is
dropped. To compile libCGAL_Qt5 and demos, you must set the cmake
or environment variable
Qt5_DIR
to point to the path to the directory containing the fileQt5Config.cmake
created by your Qt5 installation. If you are using the open source edition it should be/path-to/qt-everywhere-opensource-src-<version>/qtbase/lib/cmake/Qt5
. - The code of the 3D demos now uses modern OpenGL, with shaders, instead of the fixed pipeline API of OpenGL-1.
- The Microsoft Windows Visual C++ compiler 2015 (VC14) is now supported. However, since this compiler is not officially supported by Intel TBB 4.4 and Qt 5.5 (the latest versions available at the time of this release), the parallelism features of CGAL and Qt5 demos will not work.
L Infinity Segment Delaunay Graphs (new package)
- The package provides the geometric traits for constructing the segment Delaunay graph in the max-norm (L Infinity). The traits also contain methods to draw the edges of the dual of the segment Delaunay graph in the max-norm i.e., the segment Voronoi diagram in the max-norm. The algorithm and traits rely on the segment Delaunay graph algorithm and traits under the Euclidean distance. The segment Voronoi diagram in the max-norm has applications in VLSI CAD.
Advancing Front Surface Reconstruction (new package)
- This package provides a greedy algorithm for surface reconstruction from an unorganized point set. Starting from a seed facet, a piecewise linear surface is grown by adding Delaunay triangles one by one. The most plausible triangles are added first, in a way that avoids the appearance of topological singularities.
Triangulated Surface Mesh Shortest Paths (new package)
- The package provides methods for computing shortest path on triangulated surface meshes. Given a set of source points on the surface, this package provides a data structure that can efficiently provides the shortest path from any point on the surface to the sources points. There is no restriction on the genus or the number of connected components of the mesh.
Triangulated Surface Mesh Skeletonization (new package)
- This package provides a (1D) curve skeleton extraction algorithm for a triangulated polygonal mesh without borders based on the mean curvature flow. The particularity of this skeleton is that it captures the topology of the input. For each skeleton vertex one can obtain its location and its corresponding vertices from the input mesh. The code is generic and works with any model of the `FaceListGraph` concept.
3D Point-Set Shape Detection (new package)
- This package implements the efficient RANSAC method for shape detection, contributed by Schnabel et al. From an unstructured point set with unoriented normals, the algorithm detects a set of shapes. Five types of primitive shapes are provided by this package: plane, sphere, cylinder, cone and torus. Detecting other types of shapes is possible by implementing a class derived from a base shape.
2D Visibility (new package)
- This package provides several variants to compute the visibility area of a point within polygonal regions in two dimensions.
Polygon Mesh Processing (new package)
- This package implements a collection of methods and classes for polygon mesh processing, ranging from basic operations on simplices, to complex geometry processing algorithms. The implementation of this package mainly follows algorithms and references given in Botsch et al.'s book on polygon mesh processing.
General
- Support for unordered sets and maps of the stdlib and of boost for handle and index classes.
Approximation of Ridges and Umbilics on Triangulated Surface Meshes
- This package now supports any model of the concept
FaceGraph
. - Breaking change: The package no longer supports models of
TriangulatedSurfaceMesh
which are not at the same time models of the conceptFaceGraph
.
dD Geometry Kernel
- Epick_d gains 3 new functors:
Construct_circumcenter_d
,Compute_squared_radius_d
,Side_of_bounded_sphere_d
. Those are essential for the computation of alpha-shapes.
2D Arrangements
- Introduced a new traits class, called
Arr_polycurve_traits_2<SubcurveTraits>
, which handles general piece-wise (polycurve) curves. The pieces do not necessarily have to be linear. - Introduced two new concepts called
ArrangementApproximateTraits_2
andArrangementConstructXMonotoneCurveTraits_2
.- The existing
ArrangementLandmarkTraits_2
concept, which has two requirements, now refines the two respective concepts above. - The template parameter of the existing
Arr_polyline_traits_2<SegmentTraits>
template must be substituted with a traits class that is a model of theArrangementConstructXMonotoneTraits_2
concept among the other whenArr_polyline_traits_2
is instantiated.
- The existing
2D Minkowski Sums
- Added support for polygons with holes and optimized the construction
of Minkowski sums.
- Introduced an implementation of the "reduced convolution" method, a variant of the method described in "2D Minkowski Sum of Polygons Using Reduced Convolution" by Behar and Lien. The new method supports polygons with holes and in many cases out performs the implementation of the existing (full) convolution method.
- Introduced two new classes that decompose polygons into convex
pieces (models of the
PolygonConvexDecomposition_2
concept) based on vertical decomposition and constrained Delaunay triangulation, respectively. These new models also support the convex decomposition of polygons with holes.
3D Periodic Triangulations
- Rename
Periodic_3_triangulation_traits_3
toPeriodic_3_Delaunay_triangulation_traits_3
. - Rename the concept
Periodic_3TriangulationTraits_3
toPeriodic_3DelaunayTriangulationTraits_3
. - Create
Periodic_3_triangulation_traits_3
and the conceptPeriodic_3TriangulationTraits_3
.
2D Conforming Triangulations and Meshes
- Add an optimization method
CGAL::lloyd_optimize_mesh_2()
that implements the Lloyd (or Centroidal Voronoi Tessellation) optimization algorithm in a Constrained Delaunay Triangulation. For optimization, the triangulation data structure on which the mesher relies needs itsVertexBase
template parameter to be a model of the new conceptDelaunayMeshVertexBase_2
.
Point Set Processing and Surface Reconstruction from Point Sets
- Add the function
CGAL::compute_vcm()
for computing the Voronoi Covariance Measure (VCM) of a point set. The output of this function can be used with the functionCGAL::vcm_is_on_feature_edge()
to determine whether a point is on or close to a feature edge. The former function is also internally used byCGAL::vcm_estimate_normals()
to estimate the normals of a point set and it is particularly suited to point sets with noise.
Spatial Sorting
- Add the possibility to sort points on a sphere along a space-filling
curve using the functions
CGAL::hilbert_sort_on_sphere
andCGAL::spatial_sort_on_sphere
.
Geometric Object Generators
- Add new random generator of points in a 2D and 3D triangle and in a
tetrahedron (
CGAL::Random_points_in_triangle_2
,CGAL::Random_points_in_triangle_3
,CGAL::Random_points_in_tetrahedron_3
).
Release 4.6.2
Release date: August 2015
This release only fixes bugs. See the list of fixed bugs on Github:
https://github.com/CGAL/cgal/issues?q=milestone%3A4.6.2
Release 4.6.1
Release date: June 2015
This release only fixes bugs. See the list of fixed bugs on Github:
https://github.com/CGAL/cgal/issues?q=milestone%3A4.6.1+-label%3Ainvalid
Release 4.6
Release date: April 2015
Installation
- The required version of Boost is now 1.48 or higher.
2D Polyline Simplification (new package)
- This package enables to simplify polylines with the guarantee that the topology of the polylines does not change. This can be done for a single polyline as well as for a set of polyline constraints in a constrained triangulation. The simplification can be controlled with cost and stop functions.
2D Generalized Barycentric Coordinates (new package)
- This package offers an efficient and robust implementation of two-dimensional closed-form generalized barycentric coordinates defined for simple two-dimensional polygons.
Scale-Space Surface Reconstruction (new package)
- This new package provides a class gathering a dedicated smoothing algorithm and some convenience functions to help the creation of a surface out of a point set using the 3D Alpha Shapes package. The particularity of this reconstruction pipeline is that the input point are in the output and no new points are created. Note that in the current version, the output is a triangle soup that is not necessarily a valid (manifold) polyhedral surface.
Surface Mesh (new package)
- The surface mesh class provided by this package is an implementation
of the halfedge data structure allowing to represent polyhedral
surfaces. It is an alternative to the packages
CGAL::Polyhedron_3
andCGAL::HalfedgeDS
.
dD Triangulation (new package)
- This new package provides classes for manipulating triangulations in Euclidean spaces whose dimension can be specified at compile-time or at run-time. It also provides a class that represents Delaunay triangulations.
dD Convex Hulls and Delaunay Triangulations
- This package is deprecated and the new package Triangulation should be used instead.
dD Geometry Kernel
- It has been reported that the recently introduced
Epick_d
kernel may not work with Intel C++ Compiler prior to version 15. Documentation has been updated.
3D Convex Hulls
- Add functions
halfspace_intersection_3
andhalfspace_intersection_with_constructions_3
to compute the intersection of halfspaces defining a closed polyhedron. - Fix a bug introduced in CGAL 4.5 that can appear while computing the convex hull of coplanar points.
- Fix a robustness issue in
Convex_hull_traits_3
. This traits is used by default with the kernelExact_predicates_inexact_constructions_kernel
. - The function
CGAL::convex_hull_incremental_3
is deprecated and the functionconvex_hull_3
should be used instead.
Combinatorial Maps and Linear Cell Complex
- Added
correct_invalid_attributes
,set_automatic_attributes_management
andare_attributes_automatically_managed
methods inCombinatorialMap
concept. This allows high level operations to not update non void attributes during massive calls of these operations, but only after the end of their executions.
2D Triangulations
- The class
Constrained_triangulation_plus_2
now can handle polylines as constraints. - As a consequence a
Constraint_id
has been introduced which replacespair<Vertex_handle,Vertex_handle>
as identifier of a constraint.
3D Mesh Generation
- Add member functions
output_boundary_to_off
andoutput_facets_in_complex_to_off
in the classCGAL::Mesh_complex_3_in_triangulation_3
to export the boundary of a domain or a subdomain.
3D Fast Intersection and Distance Computation
- Add new constructors to
AABB_halfedge_graph_segment_primitive
andAABB_face_graph_triangle_primitive
in order to be able to build primitives one by one.
Spatial Searching
- Fixed a bug in
CGAL::Splitters.h
sliding midpoint rule, where degenerated point sets (e.g.,points on segment) caused the kd-tree to get linear. - Improved performance of
Orthogonal_k_neighbor_search
. Note that VC 2013 does not compileboost::container::deque
of Boost 1_55 and does hence have a workaround which does not have the improvement. - Breaking change: The concept
OrthogonalDistance
has new function overloads formin_distance_to_rectangle
andmax_distance_to_rectangle
with an additional reference parameterstd::vector
. - Breaking change: The order of the points in the iterator range
[tree.begin(),tree.end()]
is not the order of insertion of the points into the tree. This was not guaranteed before but might have been observed and exploited by users. - Derived
kd_tree_leaf_node
andkd_tree_internal_node
fromkd_tree_node
to save memory.
Geometric Object Generators
- Add a new function
random_convex_hull_in_disc_2
that efficiently generates a random polygon as the convex hull of uniform random points chosen in a disc.
Release 4.5.2
Release date: February 2015
General
- Fix a bug that prevented the compilation with recent versions of Boost (>=1.56) when explicit conversions operators (from C++11) are supported. That prevented the compilation with Microsoft Visual Studio 2013.
3D Convex Hulls
- Fix a non-robust predicate bug that was showing up when input points where lexicographically sorted.
3D Mesh Generation
- Fix a bug in the sliver perturbation optimization method. It could create some holes on the surface of the mesh.
Release 4.5.1
Release date: December 2014
3D Mesh Generation
- Fix a bug in the sliver exudation preservation of boundaries.
Release 4.5
Release date: October 2014
Installation
- Changes in the set of supported platforms:
- The Microsoft Windows Visual C++ compiler 2008 (VC9) is no longer supported since CGAL-4.5.
- Since CGAL version 4.0, Eigen was the recommended third-party library to use with Planar Parameterization of Triangulated Surface Meshes, Surface Reconstruction from Point Sets, Approximation of Ridges and Umbilics on Triangulated Surface Meshes, and Estimation of Local Differential Properties of Point-Sampled Surfaces packages. From CGAL version 4.5, Taucs, Blas and Lapack are no longer supported.
- CGAL is now compatible with the new CMake version 3.0.
Triangulated Surface Mesh Deformation (new package)
- This package allows to deform a triangulated surface mesh under
positional constraints of some of its vertices without requiring any
additional structure other than the surface mesh itself. The methods
provided implements an as-rigid-as-possible deformation. Note that
the main class name has changed between the 4.5-beta1 and the 4.5
releases to better match the CGAL naming conventions (from
CGAL::Deform_mesh
toCGAL::Surface_mesh_deformation
).
CGAL and the Boost Graph Library (major changes)
- Cleanup of the
HalfedgeGraph
concept. In particular:- Introduction of the notion of
halfedge_descriptor
in the specialization of the classboost::graph_traits
. - Deprecation of
halfedge_graph_traits
. - A model of
HalfedgeGraph
is considered as an undirected graph. Thus any call toedges()
should be replaced byhalfedges()
andnum_edges()
now returns the number of (undirected) edges. - Breaking change:
is_border_edge
andis_border_halfedge
properties are removed. The free functionsis_border()
andis_border_edge()
should be used instead. - Renaming of
HalfedgeGraph
specific free functions.
- Introduction of the notion of
- Introduction of the
FaceGraph
concept. - Adaptation of the package Triangulated Surface Mesh Simplification
and of the class
AABB_halfedge_graph_segment_primitive
from the package 3D Fast Intersection and Distance Computation to the API change. - Update of the package Triangulated Surface Mesh Segmentation and
of the class
AABB_face_graph_triangle_primitive
from the package 3D Fast Intersection and Distance Computation to accept model of the newly introduced concepts. - Offer Euler operations as free functions for models of the graph concepts provided by CGAL.
- Specialization of
boost::graph_traits
forOpenMesh::PolyMesh_ArrayKernelT
as proof of concept. AOpenMesh::PolyMesh_ArrayKernelT
becomes a model of the aforementioned concepts when includingCGAL/boost/graph/graph_traits_PolyMesh_ArrayKernelT.h
.
dD Geometry Kernel
- A new model
Epick_d
of theKernel_d
concept is introduced. It provides better performance through arithmetic filtering and specializations for fixed dimensions. It may not work with compilers as old as gcc-4.2, but was tested with gcc-4.4.
3D Convex Hulls
- Clean up the documentation of the concepts
2D Arrangements
- Fixed a bug in removing an unbounded curve (e.g., a ray) from an arrangement induced by unbounded curves.
2D Snap Rounding
- Replaced use of private
kd_tree
with CGAL's officialKd_tree
fromSpatial_searching
package; results in a small performance gain. Removed the privatekd_tree
package.
3D Triangulations
- Add an experimental parallel version of the Delaunay triangulation and the regular triangulation algorithms, which allows parallel insertion and removal of point ranges.
- Add caching of circumcenters to
Regular_triangulation_cell_base_3
. The cache value is computed whencell->circumcenter()
orrt.dual(cell)
functions are called.
3D Periodic Triangulations
- Add a method to locate point with inexact predicates.
3D Mesh Generation
- Add a new constructor for the class
Labeled_mesh_domain_3
which takes anIso_cuboid_3
. - Add a new labeling function wrapper for meshing multi-domain.
- The meshing functionality in the Qt demos in
demo/Polyhedron/
anddemo/Mesh_3/
can now use the handling of 1d-features, that exists in CGAL since version 3.8. - Add an experimental parallel version of the 3D mesh refinement and mesh optimization methods.
Point Set Processing and Surface Reconstruction from Point Sets
- The former demo has been removed and is fully merge in the Polyhedron demo.
Point Set Processing
- Workaround a bug in dijsktra shortest path of boost 1.54 by shipping and using the boost header from the 1.55 release. This header will be used only if you are using the version 1.54 of boost.
Triangulated Surface Mesh Simplification
- Breaking change: Due to the cleanup of the concepts of the
package CGAL and the Boost Graph Library, the named parameter
edge_is_border_map
has been removed, and the named parameteredge_is_constrained_map
now expects a property map with an edge descriptor as key type (vs. halfedge descriptor before). - Add some optimization in the code making the implementation faster
(depending on the cost and the placement chosen). However, for an
edge which collapse is not topologically valid, the vector of
vertices of the link provided by its profile might contains
duplicates, thus also breaking the orientation guarantee in the
vector. This must not be a problem for users as the edge is not
collapsible anyway but if it is a absolute requirement for user
defined cost/placement, defining the macro
CGAL_SMS_EDGE_PROFILE_ALWAYS_NEED_UNIQUE_VERTEX_IN_LINK
will restore the former behavior.
dD Spatial Searching
- Added methods
reserve(size_t size)
andsize_t capacity()
to classKd_tree
to allocate memory to storesize
points and to report that number (STL compliance).
STL Extensions for CGAL
- Add
Compact_container::operator[]
, allowing a direct access to the ith element of a compact container. - Add
Concurrent_compact_container
, a compact container which allows concurrent insertion and removal.
Release 4.4
Release date: April 2014
Installation
- Additional supported platforms:
- The Apple Clang compiler version 5.0 is now supported on OS X Mavericks.
- The Microsoft Windows Visual C++ compiler 2013 (VC12) is now supported.
Triangulated Surface Mesh Segmentation (new package)
- This package implements the segmentation of triangulated surface meshes based on the Shape Diameter Function (SDF). In addition, it also provides functions to generate segmentations based on a user defined alternative to the SDF.
Number Types
- A new class
CGAL::Mpzf
is introduced on some platforms for exact ring operations. It is used to improve the speed of the evaluation of predicates in degenerate situations.
2D and 3D Geometry Kernel
- Fix a bug introduced in CGAL 4.3 when computing the intersection of two 3D triangles.
2D Polygon Partitioning
- Bug fix to make the partition algorithms working with a Lazy kernel
such as
Exact_predicates_exact_constructions_kernel
.
2D Regularized Boolean Set-Operations
- Fix two memory leaks in
CGAL::General_polygon_set_2
.
Combinatorial Maps and Linear Cell Complex
null_dart_handle
is no longer a static data member in theCombinatorialMap
concept. This implies to move the following methods ofDart
concept intoCombinatorialMap
concept:is_free
,highest_nonfree_dimension
,opposite
andother_extremity
. We also transform the static methodsvertex_attribute
andpoint
ofLinear_cell_complex
class into non static methods. You can define the CGAL_CMAP_DEPRECATED macro to keep the old behavior.
2D Arrangements
- Revise the API of polylines. In particular, construction is now done using functors and iteration is possible only on the segments of a polyline.
- Fix a bug in the Landmark point-location strategy.
2D Snap Rounding
- Fix a memory leak
2D Triangulations
- Add different overloads of the function
insert_constraints
that inserts a range of points and segments, or a range of segments. These functions uses the spatial sorting in order to speed up the time needed for the insertion.
3D Alpha Shapes
- Add member functions in
CGAL::Alpha_shape_3
to give access to the alpha status of edges and facets (get_alpha_status())
. - Add another filtration method (
filtration_with_alpha_values()
) that reports the alpha value at which each face appears in the filtration.
3D Mesh Generation
- Fix the access to functions
number_of_facets
andnumber_of_cells
inMesh_complex_3_in_triangulation_3
. - Change the internal API of the sliver perturber, to make possible for developers to optimize another criterion than the (default) minimal dihedral angle. Developers can also define a new perturbation vector (for angles we had gradient of squared circumradius, gradient of volume, gradient of minimal dihedral angle, and random) which is better suitable to optimize their criterion.
- Improve the use of cache values in
Mesh_cell_base_3
to (re)compute circumcenters and sliver criterion values only when needed.
Triangulated Surface Mesh Simplification
- Fix a bug in the way edges can be marked as non-removable by adding
a named-parameter
edge_is_constrained_map
to the functionedge_collapse
dD Spatial Searching
- Fix a documentation bug: The property map passed as template
parameter to the classes
Search_traits_adapter
andDistance_adapter
must be a lvalue property map. To avoid incorrect usage, a static assertion has been added in the CGAL code to prevent the user from instantiating these classes with an incorrect property map type.
CGAL ipelets
- Better description of the demo ipelets in the user manual
- New ipelet for pencils of circles
- New ipelet for hyperbolic geometry in Poincaré model
- The generator ipelet now generates point in a selected zone
- Hilbert sort ipelet implements two policies
Release 4.3
Release date: October 2013
The CGAL Manual
- The documentation of CGAL is now generated with Doxygen.
2D Periodic Triangulations (new package)
- This package allows to build and handle triangulations of point sets in the two dimensional flat torus. Triangulations are built incrementally and can be modified by insertion or removal of vertices. They offer point location facilities. The package provides Delaunay triangulations and offers nearest neighbor queries and primitives to build the dual Voronoi diagrams.
API Changes
2D and 3D Geometry Kernel
- The intersection functions and functors used to return a
CGAL::Object
in order to deal with the different possible return types. However, depending on the arguments it is possible to reduce the possible return types to a small set. For this reason and to take advantage of the type safety, we decided to useboost::variant
instead ofCGAL::Object
. Theresult_of
protocol is now even more useful to determine the return type of the intersection functions and functors. The change should be relatively transparent to the user thanks to the implicit constructor added toCGAL::Object
. However, it is recommended to upgrade your code. The previous behavior can be restored by defining the macroCGAL_INTERSECTION_VERSION
to 1.
2D Arrangements
- The type of the result of point location queries changed to
boost::variant
(fromCGAL::Object
). For convenience, the previous behavior can be restored by defining the macroCGAL_ARR_POINT_LOCATION_VERSION
to 1. - Introduced an optimization for operations on large and dense arrangements.
3D Fast Intersection and Distance Computation
- Following the intersection API change,
Object_and_primitive_id
has been replaced by a template classIntersection_and_primitive_id<Query>
to determine the type depending on the query object type.
CGAL and Boost Property Maps
- The
key_type
of the property maps provided by CGAL used to be an iterator. In order to be more easily re-used, thekey_type
has been changed to be thevalue_type
of the iterator. The packages that have been updated to match these changes are Point Set Processing and Surface Reconstruction from Point Sets. However, for most users this change should be transparent if the default property maps were used. For convenience, the former behavior can be enabled by defining the macroCGAL_USE_PROPERTY_MAPS_API_V1
.
Algebraic Foundations
- For convenience, add an overload of
make_rational()
taking a pair of numbers.
2D and 3D Geometry Kernel
- A
Iso_rectangle_2
can now be constructed from aBbox_2
and anIso_cuboid_3
from aBbox_3
. - The implementation of
CGAL::Object
has been updated and now usesboost::shared_ptr
andboost::any
. This implementation is faster. - Add to
Bbox_2
andBbox_3
a+=
operator as well as free functions to get the bounding box of a range of geometric objects.
Combinatorial Maps
- Two bug fixes: do not use the 2 least significant bits for cell attribute without dart support; share the mark when copying a CMap_cell_iterator.
- Add a constructor taking a given combinatorial map as argument, possibly with different dimension and/or different attributes. This allows to transform a combinatorial map.
- Add operator= and swap method.
- Add dynamic onmerge/onsplit functions that can be associated dynamically to i-attributes and which are automatically called when i-cells are split/merged.
- Add a function allowing to reverse the orientation of a combinatorial map, and another one to reverse one connected component of a combinatorial map.
3D Boolean Operations on Nef Polyhedra
- Bug-fix in IO when using
Lazy_exact_nt
as number type orExact_predicates_exact_constructions_kernel
as kernel.
2D Triangulations
- Extend the concept
TriangulationDataStructure_2
to require a more generalcopy_tds
function that allows a copy between TDS of different types. The CGAL model has been updated. - Add a way to efficiently insert a range of points with information into the 2D constrained Delaunay triangulations.
3D Triangulations
- Extend the concept
TriangulationDataStructure_3
to require a more generalcopy_tds
function that allows a copy between TDS of different types. The CGAL model has been updated. - Add an advanced function to set the infinite vertex of the triangulation for low level operations
- Fix a bug in the function inserting a range of points with info when
the
Fast_location
tag is used
2D Segment Delaunay Graph
- Add functions
insert_points
andinsert_segments
to insert a range of points and segments. These functions uses the spatial sorting in order to speed up the time needed for the insertion. The functioninsert(Input_iterator first, Input_iterator beyond, Tag_true)
has been updated to dispatch the input when possible to these functions.
2D Apollonius Graphs
- Modified insertion algorithm so that the code can handle pseudo-circles as well.
- Updated implementation of the vertex conflict predicate by a faster version.
3D Mesh Generation
- Speed-up
Mesh_3
and in particular the global optimizers (Lloyd and ODT) by introducing a parameterdo_freeze
to prevent from moving vertices which would move of very small displacements. - Introduce new data structures and options for speed-up and
compacity. Note that
Compact_mesh_cell_base_3
andMesh_vertex_base_3
are now our favoured implementations of the concepts MeshCellBase_3 and MeshVertexBase_3. - Introduce a new constructor for
Polyhedral_mesh_domain_3
that takes a bounding polyhedron to be meshed along with a polyhedral surface entirely included in it. This allows the user to mesh a polyhedral domain with internal surface(s) which can be non-watertight and even non-manifold. - Several documentation bug fixes.
- Provide the ability to plug in custom cell_base/vertex_base classes into the Mesh_triangulation_3 class.
Triangulated Surface Mesh Simplification
- Fix a segmentation fault that was happening when some edges of length 0 were in the input mesh.
3D Fast Intersection and Distance Computation
- Following the intersection API change,
Object_and_primitive_id
has been replaced by a template classIntersection_and_primitive_id<Query>
to determine the type depending on the query object type. - Introduce the class
AABB_halfedge_graph_segment_primitive
, which replaces the classAABB_polyhedron_segment_primitive
(which is now deprecated). The new class is more general and can be used with any model ofHalfedgeGraph
. - Introduce the class
AABB_face_graph_triangle_primitive
which replaces the classAABB_polyhedron_triangle_primitive
(which is now deprecated). - Document the classes
AABB_segment_primitive
andAABB_triangle_primitive
that were already used in some examples. - Add a generic primitive class
AABB_primitive
that allows to define a primitive type by defining only two property maps. - Introduce a new concept of primitive
AABBPrimitiveWithSharedData
. It allows to have some data shared between the primitives stored in aAABB_tree
. With this you can, for example have a primitive wrapping an integer which refers to the position of a geometric object in astd::vector
. Only one reference to this vector will be stored in the traits of the tree. The conceptAABBTraits
, its modelAABB_traits
and the classAABB_tree
have been updated accordingly. However, everything is backward compatible. - Fix a memory leak in the destructor of the class
AABB-tree
STL Extensions for CGAL
- Add to
Dispatch_output_iterator
andDispatch_or_drop_output_iterator
an operator to accept and dispatch a tuple of values.
Concurrency in CGAL
- Add a
FindTBB
CMake module so that one can easily link with TBB to write shared-memory parallel code. - Introduce two new tags: Sequential_tag and Parallel_tag
Release 4.2
Release date: March 2013
Installation
-
Additional supported platforms:
- The Microsoft Windows Visual C++ compiler 2012 (VC11) is now supported.
-
With Microsoft Visual C++ (all supported versions), the compiler flags
/bigobj
and/wd4503
are added by CGAL CMake scripts. -
This is the last release whose "
UseCGAL.cmake
" file (if using CGAL in a CMake build environment) contains the linelink_libraries(${CGAL_LIBRARIES_DIR} ${CGAL_3RD_PARTY_LIBRARIES_DIRS})
as this is a deprecated CMake command. The correct way to link with CGAL's libraries (as for required 3rd party libraries) is to use '
target_link_libraries
' which specifies for each build target which libraries should be linked. The following serves as example:find_package(CGAL) include(${CGAL_USE_FILE}) add_executable(myexe main.cpp) target_link_libraries(myexe ${CGAL_LIBRARIES} ${CGAL_3RD_PARTY_LIBRARIES})
We also expect further changes in CGAL's CMake setup (change of variable names, consistency of filename and output, removing essential libraries, building executables, removal of '
${CGAL_3RD_PARTY_LIBRARIES}
').
2D Arrangements
- Enhanced the 2D-arrangements demonstration program and ported it to Qt4. The new demonstration program makes use of the CGAL Graphics View framework, in which the 2D primitives are individually represented as objects in a scene. (The implementations of several demos in CGAL already make use of this framework.) This project was carried out as part of the 2012 Google Summer of Code program.
- Fixed a bug in the Walk-Along-A-Line point location strategy for arrangements induced by unbounded curves.
2D Circular Geometry Kernel
- Fix the intersection type computed when intersecting two identical circles.
- Forward correctly the result type of the linear kernel functors
2D Triangulations
- Add mechanism to avoid call stack overflow in
Delaunay_triangulation_2
andConstrained_Delaunay_triangulation_2
. - Add a constructor for
Regular_triangulation_2
andDelaunay_triangulation_2
from a range of points or a range of points with info.
2D Voronoi Diagram Adaptor
- Bug-fix: Add ccb() method in face type as documented.
3D Minkowski Sum of Polyhedra
- Fix a memory leak.
3D Fast Intersection and Distance Computation
- Update requirements of the concepts
AABBTraits
andAABBGeomTraits
to match the implementation of the package.
Generator
- Addition of the
Combination_enumerator
STL Extensions
- Introduction of
CGAL::cpp11::result_of
as an alias to the tr1 implementation from boost of theresult_of
mechanism. When all compilers supported by CGAL will have a Standard compliant implementation of the C++11decltype
feature, it will become an alias tostd::result_of
.
Surface Reconstruction from Point Sets
- Performance improvements and addition of an option to better reconstruct undersampled zones. The poisson reconstruction plugin of the Polyhedron demo has an option to switch it on.
Release 4.1
Release date: October 2012
Installation
- Additional supported platforms:
- The Apple Clang compiler versions 3.1 and 3.2 are now supported on Mac OS X.
- Improved configuration for essential and optional external third party software
- Added more general script to create CMakeLists.txt files:
cgal_create_CMakeLists
- Availability tests for C++11 features are now performed with the help of Boost.Config. A Boost version of 1.40.0 or higher is needed to use C++11 features.
2D Arrangement
- Improved the implementation of the incremental randomized trapezoidal decomposition point-location strategy. The new implementation enables point location in unbounded arrangements. It constructs a search structure of guaranteed linear size with guaranteed logarithmic query time.
2D Convex Hulls and Extreme Points
- Speed up the preprocessing stage of the Akl-Toussaint implementation
(used by the free function
convex_hull_2
when forward iterators are provided as input).
Combinatorial Maps
- Minor bugfix; replace some functors by methods.
Linear Cell Complex
- Improve the demo: add a widget showing all the volumes and an operation to create a Menger sponge.
Kernels
- All Kernel functors now support the result_of protocol.
STL_Extensions for CGAL
- The namespace
cpp0x
has been renamedcpp11
. The old name is still available for backward compatibility.
Release 4.0.2
Release date: Jul 2012
This is a bug fix release. It fixes a bug in the CMakeLists.txt
for
CGAL-4.0.1, that prevented even building the libraries.
Release 4.0.1
Release date: Jul 2012
This is a bug fix release. Apart various minor fixes in the documentation, the following has been changed since CGAL-4.0:
2D Voronoi Diagram Adaptor (re-added)
- The package 2D Voronoi Diagram Adaptor was temporarily removed from the CGAL distribution because of license issues. That package is now back into CGAL.
2D and 3D Geometry Kernel
- Fix a bug in the
Segment_3-Triangle_3
intersection function in the case the segment is collinear with a triangle edge. - Fix a bug in the
Projection_traits_.._3
class in the case a segment was parallel to the x-axis.
Algebraic Kernel
- Avoid the linking error "duplicate symbols" when two compilation units using the algebraic kernel are linked.
3D Boolean Operations on Nef Polygons Embedded on the Sphere
- Fix a memory leak due to the usage of an internal mechanism that has
been replaced by
boost::any
. This also influences the packages 2D Boolean Operations on Nef Polygons, 3D Boolean Operations on Nef Polyhedra, Convex Decomposition of Polyhedra, and 3D Minkowski Sum of Polyhedra.
2D Arrangement
- Fix several memory leaks.
2D Mesh Generation
- Fix a compilation error in the header
<CGAL/Mesh_2/Do_not_refine_edges.h>
when g++ version 4.7 is used.
Surface Mesh Generation and 3D Mesh Generation
- Fix an important bug in the
CGAL_ImageIO
library, that could lead to wrong result when meshing from a 3D image. - Fix the compilation of the demo in
demo/Surface_mesher
, when Boost version 1.48 or 1.49 is used.
Surface Mesh Parameterization
- Fix a memory leak.
- Fix a compatibility issue with Eigen-3.1 of
Eigen_solver_traits
. This fix also affects the usage of that class in the package Surface Reconstruction from Point Sets.
Release 4.0
Release date: March 2012
CGAL 4.0 offers the following improvements and new functionality :
License Changes
The whole CGAL-3.x series was released under a combination of LGPLv2 (for the foundations of CGAL), and QPL (for the high-level packages). QPL was the former license of the graphical toolkit Qt, but that license is not supported by any major free software project. Furthermore, the terms of the LGPLv2 license are ambiguous for a library of C++ templates, like CGAL.
The CGAL project, driven by the CGAL Editorial Board, has decided to change the license scheme of CGAL. We increased the major number of the CGAL version to '4' in order to reflect this license change. The CGAL-4.x series is released under:
- LGPLv3+ (that is LGPL "either version 3 of the License, or (at your option) any later version"), for the foundations of CGAL, instead of LGPLv2,
- GPLv3+ for the high-level packages, instead of QPL.
General
- On Windows, CGAL libraries are now built by default as shared libraries (also called DLL). To run applications that use .dll files of CGAL, you must either copy the .dll files into the directory of the application, or add the path of the directory that contains those .dll files into the PATH environment variable.
- On Windows, the CMake scripts of CGAL now search for shared version of the Boost libraries. You must ensure that the .dll files of Boost are found by the dynamic linker. You can, for example, add the path to the Boost .dll files to the PATH environment variable.
- On Windows, CMake version 2.8.6 or higher is now required.
- Eigen version 3.1 or later is now the recommended third party library to use in Planar Parameterization of Triangulated Surface Meshes, Surface Reconstruction from Point Sets, Approximation of Ridges and Umbilics on Triangulated Surface Meshes, and Estimation of Local Differential Properties of Point-Sampled Surfaces packages. If you use Eigen you no longer need Taucs, Lapack or Blas to use those packages (and any other in CGAL).
Linear Cell Complex (new package)
- This package implements linear cell complexes, objects in
d-dimension with linear geometry. The combinatorial part of objects
is described by a combinatorial map, representing all the cells of
the object plus the incidence and adjacency relations between cells.
Geometry is added to combinatorial maps simply by associating a
point to each vertex of the map. This data structure can be seen as
the generalization in dD of the
Polyhedron_3
.
2D Voronoi Diagram Adaptor (temporarily removed)
- As the copyright holder of this package has not granted the right to switch from QPL to GPL, this package is removed from the distribution. Note that it is "only" an adapter, that is the functionality of point/segment/disk Voronoi diagram is offered through the Delaunay triangulation, segment Delaunay graph, and Apollonius graph.
AABB Tree
- Document constness of member functions of the
AABB_tree
class. - The class
AABB_tree
is now guaranteed to be read-only thread-safe. As usual in CGAL, this small overhead introduced for thread-safety can be deactivated by definingCGAL_HAS_NO_THREADS
.
2D Alpha Shapes
- Add an extra template parameter to the class
Alpha_shape_2
that allows a certified construction using a traits class with exact predicates and inexact constructions. - An object of type
Alpha_shape_2
can now be constructed from a triangulation.
3D Alpha Shapes
- Add an extra template parameter to the class
Alpha_shape_3
that allows a certified construction using a traits class with exact predicates and inexact constructions.
Geometric Object Generators
Random_points_in_iso_box_d
(deprecated since 3.8) has been removed. UseRandom_points_in_cube_d
instead.
Linear and Quadratic Programming Solver
- Minor bugfix.
Spatial Searching
- The const-correctness of this package have been worked out. The transition for users should be smooth in general, however adding few const in user code might be needed in some cases.
- The class
Kd_tree
is now guaranteed to be read-only thread-safe. As usual in CGAL, this small overhead introduced for thread-safety can be deactivated by definingCGAL_HAS_NO_THREADS
. - Bug-fix in
Orthogonal_incremental_neighbor_search
andIncremental_neighbor_search
classes. Several calls tobegin()
now allow to make several nearest neighbor search queries independently.
STL Extension
CGAL::copy_n
is now deprecated forCGAL::cpp0x::copy_n
which usesstd::copy_n
, if available on the platform.CGAL::successor
andCGAL::predecessor
are now deprecated forCGAL::cpp0x::next
andCGAL::cpp0x::prev
. These functions use the standard versions if available on the platform. Otherwise,boost::next
andboost::prior
are used.
Triangulation_2
- Fix a thread-safety issue in
Delaunay_triangulation_2
remove functions. As usual in CGAL, the small overhead introduced for thread-safety can be deactivated by definingCGAL_HAS_NO_THREADS
. - Add extraction operator for the class
Constrained_triangulation_2
(and thus to all inheriting classes).
Release 3.9
Release date: September 2011
CGAL 3.9 offers the following improvements and new functionality :
General
- The class
Root_of_2
is now deprecated. It is recommended to use the classSqrt_extension
instead. - The class
Sqrt_extension
is now used everywhere in CGAL where an algebraic number of degree 2 is needed. This change has been done in theRoot_of_traits
mechanism (indirectly packages 2D Circular kernel and 3D Spherical kernel) and the packages 2D Segment Delaunay Graphs and 2D Arrangements. - Various fixes in the manual.
Combinatorial Maps (new package)
- This package provides a new combinatorial data structure allowing to describe any orientable subdivided object whatever its dimension. It describes all cells of the subdivision and all the incidence and adjacency relations between these cells. For example it allows to describe a 3D object subdivided in vertices, edges, faces and volumes. This data structure can be seen as the generalization in dD of the halfedge data structure.