From 9f986ea9ef75d50d1592130cbb8a245a92a0a60e Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Thu, 19 Oct 2017 13:56:51 +0200 Subject: [PATCH 01/23] Add a function and associated test that orient all the connected components of a triangulated face graph positively. --- .../Polygon_mesh_processing/orientation.h | 105 +++++++++++++++++- .../Polygon_mesh_processing/CMakeLists.txt | 1 + .../test_orient_cc.cpp | 24 ++++ 3 files changed, 128 insertions(+), 2 deletions(-) create mode 100644 Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index ba2d27a2197..c02bb9113d4 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -25,12 +25,14 @@ #include - #include +#include #include #include #include #include +#include +#include #include #include @@ -114,7 +116,21 @@ namespace internal{ Orientation p1p2p3_2d = orientation_2(p1, p2, p3); Orientation p2p1p4_2d = orientation_2(p2, p1, p4); - CGAL_assertion( p1p2p3_2d!=COLLINEAR || p2p1p4_2d!=COLLINEAR ); // no self-intersection + if(!( p1p2p3_2d!=COLLINEAR || p2p1p4_2d!=COLLINEAR )) + { + Projection_traits_xz_3 p_gt_bis; + typename Projection_traits_xz_3::Orientation_2 orientation_2_bis = p_gt_bis.orientation_2_object(); + p1p2p3_2d = orientation_2_bis(p1, p2, p3); + p2p1p4_2d = orientation_2_bis(p2, p1, p4); + if(!( p1p2p3_2d!=COLLINEAR || p2p1p4_2d!=COLLINEAR )) + { + Projection_traits_yz_3 p_gt_last; + typename Projection_traits_yz_3::Orientation_2 orientation_2_last = p_gt_last.orientation_2_object(); + p1p2p3_2d = orientation_2_last(p1, p2, p3); + p2p1p4_2d = orientation_2_last(p2, p1, p4); + } + } + CGAL_assertion( p1p2p3_2d!=COLLINEAR || p2p1p4_2d!=COLLINEAR );//no self-intersection if ( p1p2p3_2d == COLLINEAR) return p2p1p4_2d == LEFT_TURN; @@ -335,6 +351,91 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh) } } +/** +* \ingroup PMP_orientation_grp +* makes the orientation of all the connected_components of a `TriangleMesh` positive. +* A closed polygon mesh is considered to have a positive orientation if the normal vectors +* to all its faces point outside the domain bounded by the polygon mesh. +* The normal vector to each face is chosen pointing on the side of the face +* where its sequence of vertices is seen counterclockwise. +* +* @tparam TriangleMesh a model of `FaceListGraph` and `MutableFaceGraph` with no self-intersection. +* @tparam NamedParameters a sequence of \ref namedparameters +* +* @param tm a triangulated `TriangleMesh` +* @param np optional sequence of \ref namedparameters among the ones listed below +* +* \cgalNamedParamsBegin + * \cgalParamBegin{vertex_point_map} + * the property map with the points associated to the vertices of `tm`. + * If this parameter is omitted, an internal property map for + * `CGAL::vertex_point_t` should be available in `TriangleMesh` + * \cgalParamEnd + * \cgalParamBegin{face_index_map} + * a property map containing the index of each face of `tm`. + * \cgalParamEnd + * \cgalNamedParamsEnd +*/ +template +void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) +{ + typedef boost::graph_traits GT; + typedef typename GT::vertex_descriptor vertex_descriptor; + typedef typename GT::face_descriptor face_descriptor; + typedef typename GetVertexPointMap::const_type Vpm; + typedef typename GetFaceIndexMap::const_type Fid_map; + + if (!is_triangle_mesh(tm)) return ; + + Vpm vpm = boost::choose_param(get_param(np, internal_np::vertex_point), + get_const_property_map(boost::vertex_point, tm)); + + Fid_map fid_map = boost::choose_param(get_param(np, internal_np::face_index), + get_const_property_map(boost::face_index, tm)); + + std::vector face_cc(num_faces(tm), std::size_t(-1)); + + // set the connected component id of each face + std::size_t nb_cc = connected_components(tm, + bind_property_maps(fid_map,make_property_map(face_cc)), + parameters::face_index_map(fid_map)); + + if (nb_cc == 1) + return; + + // extract a vertex with max z coordinate for each connected component + std::vector xtrm_vertices(nb_cc, GT::null_vertex()); + BOOST_FOREACH(vertex_descriptor vd, vertices(tm)) + { + face_descriptor test_face = face(halfedge(vd, tm), tm); + if(test_face == GT::null_face()) + continue; + std::size_t cc_id = face_cc[get(fid_map,test_face )]; + if (xtrm_vertices[cc_id]==GT::null_vertex()) + xtrm_vertices[cc_id]=vd; + else + if (get(vpm, vd).z()>get(vpm,xtrm_vertices[cc_id]).z()) + xtrm_vertices[cc_id]=vd; + } + std::vector > ccs(nb_cc); + BOOST_FOREACH(face_descriptor fd, faces(tm)) + { + ccs[face_cc[get(fid_map,fd)]].push_back(fd); + } + + //orient ccs outward + for(std::size_t id=0; id +#include +#include + +#include +#include + +using namespace CGAL; +namespace PMP = Polygon_mesh_processing; + +typedef Exact_predicates_inexact_constructions_kernel Kernel; +typedef Surface_mesh Surface_mesh; + + +int main() +{ + + std::ifstream input("data-coref/nested_cubes_invalid_volume.off"); + assert(input); + ::Surface_mesh sm; + input >> sm; + PMP::orient_connected_components(sm, PMP::parameters::all_default()); + return 0; +} From e7f61869cbdb106a2c50c287bb76bc24b890c03e Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Thu, 19 Oct 2017 15:37:21 +0200 Subject: [PATCH 02/23] Fix case triangles orthogonal to XY plane. --- Installation/changes.html | 5555 +++++++++++++++++ .../Polygon_mesh_processing/orientation.h | 20 +- 2 files changed, 5565 insertions(+), 10 deletions(-) create mode 100644 Installation/changes.html diff --git a/Installation/changes.html b/Installation/changes.html new file mode 100644 index 00000000000..f6cda02f92d --- /dev/null +++ b/Installation/changes.html @@ -0,0 +1,5555 @@ + + + + + + + + + + CGAL - Release History + + + + + + + + + + + + + + +
+

Release History

+ +
+ + + +
+ + + +
4.12  (April 2018) +
4.11  (September 2017) +
4.10  (May 2017) +
4.9  (September 2016) +
4.8  (April 2016) +
4.7  (October 2015) +
4.6.2  (August 2015) +
4.6.1  (June 2015) +
4.6  (April 2015) +
4.5.2  (February 2015) +
4.5.1  (December 2014) +
4.5  (October 2014) +
4.4  (April 2014) +
4.3.1  (November 2013) +
4.3  (October 2013) +
4.2  (March 2013) +
4.1  (September 2012) +
4.0.2  (July 2012) +
4.0.1  (July 2012) +
4.0  (March 2012) +
3.9  (September 2011) +
3.8  (April 2011) +
3.7  (October 2010) +
3.6.1  (June 2010) +
3.6  (March 2010) +
3.5.1  (December 2009) +
3.5  (October 2009) +
3.4  (January 2009) +
3.3.1 (August 2007) +
3.3 (May 2007) +
3.2.1 (July 2006) +
3.2 (May 2006) +
3.1 (December 2004) +
3.0.1 (February 2004) +
3.0 (October 2003) +
2.4 (May 2002) +
2.3 (August 2001) +
2.2 (October 2000) +
2.1 (January 2000) +
2.0 (June 1999) +
1.2 (January 1999) +
1.1 (July 1998) +
1.0 (April 1998) +
0.9 (June 1997) +
+ +		 + + +
+Number of lines of code of CGAL
+(using David A. Wheeler's +'SLOCCount', restricted to the include/CGAL/ +and src/ directories). +
Releases size graph +
+		 +
+ +
+

Release 4.12

+
+

Release date: April 2018

+ +

2D Movable Separability of Sets

+
    +

  • A new packaged 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.<\p> + +

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

2D Alpha Shapes

+
    +
  • It is now possible to use CGAL::Periodic_2_triangulation_2 + as underlying triangulation for Alpha_shape_2.
    • +
+ +

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 + class Triangulation_hierarchy_vertex_base_2, which is identical.
    • +
  • Breaking change: + The functions circumcenter(), side_of_oriented_circle(), + and is_extensible_in_1_sheet_h[12]() are related to + Delaunay triangulations and have been moved from Periodic_2_triangulation_2 + to Periodic_2_Delaunay_triangulation_2.
    • +
+ + +

3D Surface Mesh Generation

+
    +
  • + Add the function facets_in_complex_2_to_triangle_mesh() + that exports Surface_mesh_complex_2_in_triangulation_3 + facets into a MutableFaceGraph. +
    • +
+

3D Mesh Generation

+
    +
  • + Add the function facets_in_complex_3_to_triangle_mesh() + that exports Mesh_complex_3_in_triangulation_3 + facets into a MutableFaceGraph. +
    • +
+ + +

Polygon Mesh Processing

+
    +
  • Added a function for orienting connected components : +
      +
    • CGAL::Polygon_mesh_processing::orient_connected_components()
      • +
    +
    • +
  • 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

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

Point Set Processing

+
    +
  • Breaking change: the API + of CGAL::structure_point_set() is generalized to accept + other types of input than the RANSAC output.
    • +
+ + + + + + + +

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

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 + concept Kernel but must now be marked with + the explicit 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 + and Alpha_shape_mesher.
    • +
  • Alternative smoothing and meshing methods are + provided: Jet_smoother + and Advancing_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 concept Kernel are models of + this new concept. +
    • +
  • + The concept AlphaShapeTraits_2 now provides requirements + on the traits class for 2D basic alpha shapes, and + refines DelaunayTriangulationTraits_2. +
    • +
+

Interpolation

+
    +
  • Breaking change: The + concept GradientFittingTraits now additionally requests a + weighted point type Weighted_point_d and a + functor Construct_point_d. The model + CGAL::Interpolation_gradient_fitting_traits_2 has been + appropriately modified to still be a model of the + concept GradientFittingTraits. +
    • +
+

2D and 3D Triangulations

+
    +
  • Breaking change: Added a new functor + requirement, Construct_point_2, to the concepts + TriangulationTraits_2 + and RegularTriangulationTraits_2 and a new functor + requirement, Construct_point_3, to the concepts + TriangulationTraits_3 + and RegularTriangulationTraits_3. All models of the + concept Kernel already provide these functors. +
    • +
  • Breaking change: Introduced the + concepts RegularTriangulationVertexBase_2 and + RegularTriangulationVertexBase_3. These concepts + describe the requirements on classes meant to represent a vertex of a + regular triangulation. Concepts that previously + refined TriangulationVertexBase_2 or + TriangulationVertexBase_3 but described in fact a vertex + class used in a regular triangulation, such as the + concept MeshVertexBase_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 to + Traits::Point_[23] for basic and Delaunay triangulations + or to + Traits::Weighted_point_[23] for regular + triangulations. Consequently: +
      +
    • + The concept RegularTriangulationVertexBase_2 now + requests a Point type (equal + to Traits::Weighted_point_2) +
      • +
    • + The concept RegularTriangulationCellBase_3 now + requests a Point type instead of + a Weighted_point type (but still equal + to Traits::Weighted_point_3) +
      • +
    • + The concept DelaunayTriangulationCellBase_3 now + requests a Point type instead of + a Point_3 type (but still equal + to Traits::Point_3). +
      • +
    +
    • +
  • + Introduced a new concept, + RegularTriangulationCellBaseWithWeightedCircumcenter_3, + which describes the requirements on a cell of a regular triangulation + that caches its circumcenter. The existing class + Regular_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 + functors Construct_weighted_circumcenter_3, + Compute_squared_radius_3, and + Compute_squared_radius_smallest_orthogonal_sphere_3. + This class can be used as traits class in the the Mesh_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 + inherits Periodic_3_triangulation_traits_3. +
    • +
  • Breaking change: Some geometric access functions + in Periodic_3_triangulation_3 were renamed. The + introduction of Periodic_3_regular_triangulation_3 + required to distinguish between functions such + as segment() 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 containing construct 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 class + Regular_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 + from Triangulation::Point to + TriangulationTraits::Point_3 to reflect that it is a + weightless point. +
    • +
  • Breaking change: The + function invalidate_circumcenter() of the + concept MeshCellBase_3 is renamed to + invalidate_weighted_circumcenter_cache() and moved to + the new concept + RegularTriangulationCellBaseWithWeightedCircumcenter_3, + which the concept MeshCellBase_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 + concepts BidirectionalGraph and + EdgeAndVertexListGraph and of the + concept MutableFaceGraph. 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. The Seam_mesh is a + graph adaptor which allows to create virtual borders when marking + edges as seam edges. +
    • +
  • Add the functions read_off() + and write_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 + requires Boost.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 + concept MutableFaceGraph. Models provided by CGAL have + been updated. +
    • +
+ +

2D and 3D Linear Geometry Kernel

+
    +
  • Breaking change: The function compare_slopes() was renamed compare_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 function compare_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 + concept MutableFaceGraph
    • +
  • The function convex_hull_3_to_polyhedron_3() is + deprecated and convex_hull_3_to_face_graph.h should be + used instead.
    • +
  • The class Convex_hull_traits_3 now documents a nested + type Polygon_mesh instead + of Polyhedron_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 + renamed Linear_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 concept Kernel/
    • +
  • The class Regular_triangulation_2 can take a kernel as + template argument, that is one no longer has to + use Regular_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 concept Kernel/
    • +
  • The class Regular_triangulation_3 can take a kernel as + template argument, that is one no longer has to + use Regular_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 of FaceGraph. +
    • +
+ +

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 renamed CGAL::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 a Nef_polyhedron_3 to any model of + the MutableFaceGraph 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 + and CGAL::Random_points_in_triangles_2).
      • +
    • on a 3D segment + (CGAL::Random_points_on_segment_3).
      • +
    +
    • +
+
+ +

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 + the CombinatorialMap 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() + and CGAL::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() + and AABB_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 + a FaceGraph and a creation + function CGAL::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 + keyword thread_local and the C+11 + class std::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 and + GeneralPolygonSetDcelFace for more details. If you use a + different simplex types, inheriting your simplices from + CGAL::Gps_face_base + and CGAL::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 + function bbox().
    • +
+

Advancing Front Surface Reconstruction

+
    +
  • Optional template functor Filter is replaced by + another optional template functor Priority. 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 + old Filter API will not compile anymore as it must be + replaced with the Priority 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 + functions compute_average_spacing(), + edge_aware_upsample_point_set(), + jet_estimate_normals(), + jet_smooth_point_set(), + and pca_estimate_normals(). To update your code simply + add as first template parameter CGAL::Sequential_tag + or CGAL::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() + and CGAL::write_ply_points_and_normals().
    • +
+

Surface Mesh Parameterization

+
    +
  • LSCM_parameterizer_3 now uses by default Eigen + instead of OpenNL as a model + of SparseLinearAlgebraTraits_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 + functions CGAL::linear_least_squares_fitting_2() + and CGAL::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 of DiagonalizeTraits). 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() + and CGAL::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 file Qt5Config.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 concept FaceGraph. +
    • +
+ +

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 and + ArrangementConstructXMonotoneCurveTraits_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 + the ArrangementConstructXMonotoneTraits_2 concept + among the other when Arr_polyline_traits_2 is + instantiated. +
      • +
    +
    • +
+ +

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 + pergorms the implementation of the exsisting (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 to + Periodic_3_Delaunay_triangulation_traits_3. +
    • +
  • Rename the concept Periodic_3TriangulationTraits_3 to + Periodic_3DelaunayTriangulationTraits_3. +
    • +
  • Create Periodic_3_triangulation_traits_3 and the + concept Periodic_3TriangulationTraits_3. +
    • +
+ +

2D Conforming Triangulations and Meshes

+
    +
  • + Add an optimization method CGAL::lloyd_optimize_mesh_2() + that implements the Lloyd (or Centroidal Voronoi Tesselation) + optimization algorithm in a Constrained Delaunay Triangulation. For + optimization, the triangulation data structure on which the mesher + relies needs its VertexBase template parameter to be a + model of the new concept DelaunayMeshVertexBase_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 + function CGAL::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 by CGAL::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 and + CGAL::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 + and CGAL::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 and + halfspace_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 kernel + Exact_predicates_inexact_constructions_kernel.
    • +
  • The function CGAL::convex_hull_incremental_3 is deprecated and + the function convex_hull_3 should be used instead.
    • +
+ + +

Combinatorial Maps and Linear Cell Complex

+
    +
  • Added correct_invalid_attributes, + set_automatic_attributes_management and + are_attributes_automatically_managed methods in + CombinatorialMap 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 replaces pair<Vertex_handle,Vertex_handle> as + identifier of a constraint. +
+ + +

3D Mesh Generation

+
    +
  • Add member functions output_boundary_to_off and + output_facets_in_complex_to_off + in the class CGAL::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 and + AABB_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 + compile boost::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 for min_distance_to_rectangle and + max_distance_to_rectangle with an additional reference + parameter std::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 + and kd_tree_internal_node from kd_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 to CGAL::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 + class boost::graph_traits.
      • +
    • Deprecation of halfedge_graph_traits.
      • +
    • A model of HalfedgeGraph is considered as an + undirected graph. Thus any call to edges() should be + replaced by halfedges() and num_edges() + now returns the number of (undirected) edges. +
    • Breaking change: is_border_edge + and is_border_halfedge properties are removed. The + free functions is_border() + and is_border_edge() should be used instead.
      • +
    • Renaming of HalfedgeGraph specific free + functions.
      • +
    +
    • +
  • 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 + for OpenMesh::PolyMesh_ArrayKernelT as proof of + concept. A OpenMesh::PolyMesh_ArrayKernelT becomes a + model of the aforementioned concepts when including + CGAL/boost/graph/graph_traits_PolyMesh_ArrayKernelT.h.
    • +
+ + +

dD Geometry Kernel

+
    +
  • A new model Epick_d of the Kernel_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 + official Kd_tree from Spatial_searching + package; results in a small performance gain. Removed the + private kd_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 when cell->circumcenter() + or rt.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 + an Iso_cuboid_3.
    • +
  • Add a new labeling function wrapper for meshing multi-domain.
    • +
  • The meshing functionality in the Qt demos + in demo/Polyhedron/ and demo/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 parameter + edge_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) and size_t + capacity() to class Kd_tree to allocate memory + to store size 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 + the CombinatorialMap concept. This implies to move the + following methods of Dart concept + into CombinatorialMap + concept: is_free, highest_nonfree_dimension, + opposite and other_extremity. We also + transform the static methods vertex_attribute + and point of Linear_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 + and number_of_cells in + Mesh_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 function + edge_collapse
    • +
+ +

dD Spatial Searching

+
    +
  • Fix a documentation bug: The property map passed as template + parameter to the classes + Search_traits_adapter and Distance_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 use boost::variant instead + of CGAL::Object. The result_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 to CGAL::Object. However, it is + recommended to upgrade your code. The previous behavior can be + restored by defining the + macro CGAL_INTERSECTION_VERSION to 1. +
    • +
+

2D Arrangements

+
    +
  • The type of the result of point location queries changed to + boost::variant (from CGAL::Object). + For convenience, the previous behavior can be restored by defining + the macro CGAL_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 class + Intersection_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, + the key_type has been changed to be + the value_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 + macro CGAL_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 + a Bbox_2 and an Iso_cuboid_3 from + a Bbox_3.
    • +
  • The implementation of CGAL::Object has been updated + and now uses boost::shared_ptr + and boost::any. This implementation is faster. +
    • +
  • Add to Bbox_2 and Bbox_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 + or Exact_predicates_exact_constructions_kernel as + kernel.
    • +
+ +

2D Triangulations

+
    +
  • Extend the concept TriangulationDataStructure_2 to + require a more general copy_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 general copy_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 + and insert_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 + function insert(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 + parameter do_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 and + Mesh_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 class + Intersection_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 class AABB_polyhedron_segment_primitive + (which is now deprecated). The new class is more general and can be + used with any model of HalfedgeGraph.
    • +
  • Introduce the class AABB_face_graph_triangle_primitive + which replaces the + class AABB_polyhedron_triangle_primitive (which is now + deprecated).
    • +
  • Document the classes AABB_segment_primitive + and AABB_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 + a AABB_tree. With this you can, for example have a + primitive wrapping an integer which refers to the position of a + geometric object in a std::vector. Only one reference + to this vector will be stored in the traits of the tree. The + concept AABBTraits, its model AABB_traits + and the class AABB_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 + and Dispatch_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 line +
    +  link_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 + and Constrained_Delaunay_triangulation_2. +
  • Add a constructor for Regular_triangulation_2 + and Delaunay_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 + and AABBGeomTraits 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 the result_of + mechanism. When all compilers supported by CGAL will have a Standard + compliant implemention of the C++11 decltype feature, it + will become an alias to + std::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 renamed cpp11. 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 defining CGAL_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. Use Random_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 defining CGAL_HAS_NO_THREADS.
    • +
  • Bug-fix in Orthogonal_incremental_neighbor_search and Incremental_neighbor_search classes. Several calls to begin() + now allow to make several nearest neighbor search queries independently.
    • +
+ +

STL Extension

+
    +
  • CGAL::copy_n is now deprecated for CGAL::cpp0x::copy_n which uses std::copy_n, if available on the platform.
    • +
  • CGAL::successor and CGAL::predecessor are now deprecated for CGAL::cpp0x::next and CGAL::cpp0x::prev. These functions + use the standard versions if available on the platform. Otherwise, boost::next and boost::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 defining CGAL_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 class Sqrt_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 the Root_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.
    • +
+ +

3D Convex Hull (major performance improvement)

+
    +
  • The quickhull implementation of CGAL (CGAL::convex_hull_3) + has been worked out to provide very better performances.
    • +
  • The function CGAL::convex_hull_3 no longer computes the plane + equations of the facets of the output polyhedron. However an example is + provided to show how to compute them easily.
    • +
  • A global function convex_hull_3_to_polyhedron_3 is now provided to extract + the convex hull of a 3D points set from a triangulation of these points.
    • +
+ +

dD Spatial Searching (major new feature added)

+
    +
  • A traits-class and distance adapter that together with a point property map, + allow to make nearest neighbor queries on keys instead of points have been added.
    • +
  • Few bug fixes in the documentation have revealed some inconsistencies + that have been corrected. Two traits class concept are now documented (RangeSearchTraits + and SearchTraits). Most other changes concerns only classes documented as advanced. + One issue that user can encounter is due to an additional requirement on the nested + class Construct_cartesian_const_iterator_d defined in the concept SearchTraits that must + provide a nested type result_type.
    • +
+ +

Spatial Sorting (major new feature added)

+
    +
  • General dimension is now supported.
    • +
  • Hilbert sorting admits now two policies: splitting at + median or at middle (see user manual).
    • +
  • Using a property map, sorting on keys instead of points is now easier
    • +
+ +

dD Kernel

+
    +
  • The d-dimensional kernel concept and models have been modified + to additionally provide two new functors Less_coordinate_d and Point_dimension_d.
    • +
+ +

2D Arrangements

+
    +
  • A new geometry-traits class that handles rational arcs, namely + Arr_rational_function_traits_2, has been introduced. + It replaced an old traits class, which handled the same family of + curves, but it was less efficient. The new traits exploits CGAL + algebraic kernels and polynomials, which were not available at + the time the old traits class was developed.
    • +
  • A new geometry traits concept called + ArrangementOpenBoundaryTraits_2 has been introduced. + A model of this concept supports curves that approach the open + boundary of an iso-rectangular area called parameter space, which can + be unbounded or bounded. The general code of the package, however, + supports only the unbounded parameter space. We intend to enhance the + general code to support also bounded parameter spaces in a future + release.
    • +
  • The deprecated member function is_at_infinity() of + Arrangement_2::Vertex has been removed. It has been previously + replaced new function is_at_open_boundary(). + +
  • The tags in the geometry traits that indicate the type of boundary of + the embedding surface were replaced by the following new tags: +
    +         Left_side_category
+         Bottom_side_category
+         Top_side_category
+         Right_side_category
+
    + It is still possible not to indicate the tags at all. Default values are assumed. This however will + produce warning messages, and should be avoided.
    • +
+
+ + +

Release 3.8

+
+

Release date: April 2011

+ +

+CGAL 3.8 offers the following improvements and new functionality :

+ +

General

+
    +
  • Boost version 1.39 at least is now required.
    • +
  • Initial support for the LLVM Clang compiler (prereleases of version 2.9).
    • +
  • Full support for the options -strict-ansi of the Intel Compiler 11, + and -ansi of the GNU g++ compiler.
    • +
  • Adding a concept of ranges. In the following releases, it will be the + way to provide a set of objects (vs. a couple of iterators).
    • +
  • Fix a memory leak in CORE polynomials.
    • +
  • Various fixes in the manual.
    • +
+ +

3D Mesh Generation (major new feature added)

+
    +
  • Adding the possibility to handle sharp features: the 3D Mesh + generation package now offers the possibility to get in the final mesh an + accurate representation of 1-dimensional sharp features present in the + description of the input domain. +
+ +

2D Triangulations (major new feature added)

+
    +
  • Add a way to efficiently insert a range of points with information + into a 2D Delaunay and regular triangulation. +
  • Add member function mirror_edge taking an edge as parameter. +
  • Fix an infinite loop in constrained triangulation. +
+ +

3D Triangulations (major new feature added)

+
    +
  • Add a way to efficiently insert a range of points with information into + a 3D Delaunay and regular triangulation. +
  • Add a member function to remove a cluster of points from a Delaunay or + regular triangulation. +
  • function vertices_in_conflict is renamed vertices_on_conflict_zone_boundary + for Delaunay and regular triangulation. Function vertices_inside_conflict_zone + is added to regular triangulation. +
  • Structural filtering is now internally used in locate function of Delaunay + and regular triangulation. It improves average construction time by 20%. +
  • Added demo. +
+ +

3D Alpha Shapes (major new feature added)

+
    +
  • The new class Fixed_alpha_shape_3 provides a robust and + faster way to compute one alpha shape (with a fixed value of alpha). +
+ + +

AABB tree

+
    +
  • Adding the possibility to iteratively add primitives to an existing + tree and to build it only when no further insertion is needed. +
+ +

2D and 3D Kernel

+
    +
  • Better handling of 2D points with elevation (3D points projected onto + trivial planes). More general traits classes (Projection_traits_xy_3, + Projection_traits_yz_3,Projection_traits_yz_3) are provided to work with + triangulations, algorithms on polygons, alpha-shapes, convex hull algorithm... + Usage of former equivalent traits classes in different packages is now deprecated. +
  • Exact_predicates_exact_constructions_kernel now better use the static filters + which leads to performance improvements. +
  • Add an overload for the global function angle, taking three 3D points. +
  • In the 2D and 3D kernel concept, the constant Boolean Has_filtered_predicates + is now deprecated. It is now required to use Has_filtered_predicates_tag + (being either Tag_true or Tag_false). +
  • Compare_distance_2 and Compare_distance_3 provide additional operators + for 3 and 4 elements. +
  • Add intersection test and intersection computation capabilities + between an object of type Ray_3 and either an object of type Line_3, Segment_3 or Ray_3. +
  • Improve intersection test performance between an object of type Bbox_3 and an object of type + Plane_3 or Triangle_3 by avoiding arithmetic filter failures. +
+ +

2D Envelope

+
    +
  • Env_default_diagram_1 is deprecated, Envelope_diagram_1 should be used instead. +
+ +

3D Envelope

+
    +
  • A new demo program called L1_Voronoi_diagram_2 has been + introduced. It demonstrates how 2D Voronoi diagrams of points under + the L1 metric are constructed using lower envelopes. +
+ + +

dD Kernel

+
    +
  • Add functor Compute_coordinate_d to Kernel_d concept. +
+ +

Geometric Object Generators

+
    +
  • CGAL::Random uses boost::rand48 instead of std::rand. +
  • Adding to CGAL::Random a way to generate random integers. +
  • Adding generators for dD points. +
+ +

Algebraic Foundations

+
    +
  • Algebraic_structure_traits now provides an Inverse functor for Fields. + There is also a new global function inverse. +
+ +

Bounding Volumes

+
    +
  • dD Min sphere of spheres has a new traits class for the min sphere of points. +
+ +

Triangulated Surface Mesh Simplification

+
    +
  • The priority queue internally used to prioritize edge simplifications is no longer + a relaxed heap but a binomial heap. This fix guarantees that all edges satisfying + a simplification criteria are removed (if possible). +
+ +

3D Boolean Operations on Nef Polyhedra

+
    +
  • Allow construction of a 3D nef polyhedron from a 3D polyhedron with normals. +
+ +

2D Arrangements

+
    +
  • Fix a bug in the method insert_at_vertices of the Arrangement_2 class. +
  • Fix several bugs in the traits class Arr_Bezier_curve_traits_2 for arrangement of Bezier curves. +
+ +

2D Minkowski Sums

+
    +
  • A bug in the convolution method was fixed. +
+
+ +

Release 3.7

+
+

Release date: October 2010

+ +

+CGAL 3.7 offers the following improvements and new functionality :

+ + +

General

+ +
    +
  • The configuration of CGAL libraries now requires CMake>=2.6. + +
  • Changes in the set of supported platforms: +
      +
    • GNU g++ 4.5 supported (with or without the compilation option + -std=c++0x). + +
    • Initial support for the option -strict-ansi of the Intel Compiler 11. + The CGAL libraries compile with that option, and most CGAL headers + have been fixed. The packages "3D Boolean Operations on Nef + Polyhedra" (Nef_3), "Convex Decomposition of Polyhedra" + (Convex_decomposition_3), and "3D Minkowski Sum of Polyhedra" + (Minkowski_sum_3) are known to still fail to compile with that + compiler flag. + +
    • The Microsoft Windows Visual C++ compiler 2010 (VC10), that was + experimentally supported by CGAL-3.6.1, is now fully supported. Note + that CMake>=2.8.2 is required for that support. + +
    • The Microsoft Windows Visual C++ compiler 2005 (VC8) is no longer + supported by the CGAL project since CGAL-3.7. + +
    • With Microsoft Windows Visual C++ (VC9 and VC10), the optional + dependencies Gmp, Mpfr, Blas, Lapack, Taucs no longer use Boost-style + name mangling. Only one variant is now provided by the CGAL Windows + installer (release, with dynamic runtime). +
    +
  • Some demos now require a version of Qt4 >= 4.3. + +
  • CGAL_PDB is no longer provided with CGAL. An alternative solution for + people interested in reading PDB files is to use ESBTL + (http://esbtl.sourceforge.net/). + +
  • Fix issues of the CGAL wrappers around the CORE library, on 64 bits + platforms. +
+ + +

Arithmetic and Algebra

+
    +
  • New models Algebraic_kernel_d_1 and Algebraic_kernel_d_2 for the + corresponding concepts. They provide generic support for various + coefficient types +
+ +

Arrangements

+
    +
  • A new model Arr_algebraic_segment_traits_2 of ArrangementTraits_2 that + supports algebraic curves of arbitrary degree in the plane +
+ + +

2D Triangulations

+
    +
  • The Delaunay and regular 2D triangulations now use a symbolic + perturbation to choose a particular triangulation in co-circular cases. + +
  • The return type of the template member function + insert(It beg, It end), taking an iterator range of points, + has been changed from int to std::ptrdiff_t. + +
  • Classes Triangulation_euclidean_traits_xy_3, Triangulation_euclidean_traits_yz_3 + and Triangulation_euclidean_traits_xz_3 are now model of the concept + ConstrainedTriangulationTraits_2. They can be used with and without intersection + of constraints. + +
  • 2D Delaunay and basic triangulations now provide vertex relocation by + the mean of these two new methods: move and move_if_no_collision. The + methods are also available for the hierarchy + (Triangulation_hierarchy_2). + +
+ +

3D Triangulations

+
    +
  • The return type of the template member function + insert(It beg, It end), taking an iterator range of points, + has been changed from int to std::ptrdiff_t. +
  • 3D Delaunay triangulations now provide vertex relocation by the mean + of these two new methods: move and move_if_no_collision. This works in + both Compact_policy and Fast_policy. +
+ +

2D and 3D Alpha Shapes

+
    +
  • The type int in the API has been changed to std::size_t + so that CGAL can deal with large data sets (64 bit addresses). +
+ + +

2D Mesh Generation

+
    +
  • The execution of the 2D mesh generator is now deterministic (same at + each run). +
+ +

3D Mesh Generation

+
    +
  • The efficiency of the 3D mesh generator has been improved (the number + of calls to the oracle per inserted vertex has globally decrease). + This is achieved through a slight change of the mesh generator strategy + which implies that a surface component that is not detected at the + surface mesher level will never be discovered by chance, owing to the + refinement of some tetrahedra, as it could happen before. + Please note that defining the macro + CGAL_MESH_3_USE_OLD_SURFACE_RESTRICTED_DELAUNAY_UPDATE switches back to + the old behavior. + +
  • A demo program is now available. +
+ +

Surface Reconstruction from Point Sets

+
    +
  • Improved performance and minor bug fix. +
+ + +

2D Range and Neighbor Search

+
    +
  • The type int in the API has been changed to std::size_t + so that CGAL can deal with large data sets (64 bit addresses). +
+ +
+ + + +

Release 3.6.1

+ +
+

Release date: June 2010

+ +

+This is a bug fix release. The following has been changed +since CGAL-3.6:

+ +

General

+ +
    +
  • Fix compilation errors with recent Boost versions (since 1.40). + +
  • Initial support for the Microsoft Visual C++ compiler 10.0 (MSVC + 2010). For that support, CMake>=2.8.2 is required. + Note also that the compiler option "/bigobj" is necessary to compile + some CGAL programs with MSVC 2010. +
+ + +

Polynomial

+
    +
  • Fix compilation errors with the Microsoft Visual C++ compiler and the + Intel C++ compiler. +
+ +

Polyhedron

+
    +
  • Fix a compilation errors in demo/Polyhedron/: +
  • issue with the location of qglobal.h of Qt4 on MacOS X, +
  • missing texture.cpp, if TAUCS is used, +
  • Fix the location of built plugins of demo/Polyhedron/, when CGAL is + configured with WITH_demos=ON +
+ +

3D Periodic Triangulations

+
    +
  • Fixed bug in the triangulation hierarchy for periodic triangulations. +
+ +

2D Mesh Generation

+
    +
  • Fix a bug that lead to precondition violation. +
  • Improve the user manual about the member function is_in_domain() of the + Face type. +
  • The 2D meshing process is now deterministic (sorting of bad faces no + longer relies on pointers comparisons). +
+ +

3D Mesh Generation

+
    +
  • Fix a linking errors (duplicate symbols) when <CGAL/refine_mesh_3.h> is + included in different compilation units. +
+ +

Spatial Searching

+
    +
  • Fix a bug in <CGAL/Orthogonal_k_neighbor_search.h> when several + nearest neighbors are at the same distance from the query point. +
+ +

IO Streams

+
    +
  • Fix a bug in <CGAL/IO/VRML_2_ostream.h> that generated VRML 2 files with + an invalid syntax for IndexedFaceSet nodes. +
+ +

Triangulation_2

+
    +
  • Add missing Compare_distance_2 functor in trait classes Triangulation_euclidean_traits_xy_3 + Triangulation_euclidean_traits_yz_3 and Triangulation_euclidean_traits_xz_3. + This was preventing calling member function nearest_vertex of Delaunay_triangulation_2 + instantiated with one of these traits. +
+
+ +

Release 3.6

+ +
+

Release date: March 2010

+ +

+CGAL 3.6 offers the following improvements and new functionality :

+ +

General

+ +
  • Boost version 1.34.1 at least is now required.
+ + +

Arithmetic and Algebra

+ +

Algebraic Kernel (new package)

+ +
    +
  • This new package is targeted to provide black-box implementations of + state-of-the-art algorithms to determine, compare and approximate real + roots of univariate polynomials and bivariate polynomial systems. It + includes models of the univariate algebraic kernel concept, based on + the library RS. +
+ +

Number Types

+ +
    +
  • Two new arbitrary fixed-precision floating-point number types have been + added: the scalar type Gmpfr and the interval type Gmpfi, based on the + MPFR and MPFI libraries respectively. +
+ + +

Geometry Kernels

+ +

2D and 3D Geometry Kernel

+
    +
  • Add new do_intersect() and intersection() overloads: +
      +
    • do_intersect(Bbox_3, Bbox_3/Line_3/Ray_3/Segment_3) +
    • intersection(Triangle_3, Line_3/Ray_3/Segment_3) +
    +
+ +

Polygons

+ +

2D Regularized Boolean Set-Operations

+
    +
  • Fixed General_polygon_set_2::arrangement() to return the proper type + of object. +
+ + +

Arrangement

+ +

2D Arrangements

+ +
  • Fixed passing a (const) traits object to the constructor of Arrangement_2. + +
  • Introduced Arrangement_2::fictitious_face(), which returns the fictitious + face in case of an unbounded arrangement. + +
  • Fixed a bug in Bezier-curve handling. + +
  • Added (back) iterator, number_of_holes(), holes_begin(), and holes_end() + to the default DCEL for backward compatibility. + +
  • Added (simple) versions of the free overlay() function. It employs the + default overlay-traits, which practically does nothing. +
+ +

Polyhedron

+
    +
  • Fix a compilation errors in demo/Polyhedron/: +
      +
    • issue with the location of qglobal.h of Qt4 on MacOS X, +
    • missing texture.cpp, if TAUCS is used, +
    +
  • Fix the location of built plugins of demo/Polyhedron/, when CGAL is + configured with WITH_demos=ON +
  • Fix a bug in test_facet function of the incremental builder: + the function did not test if while a new facet makes a vertex manifold, + no other facet incident to that vertex breaks the manifold property. +
+ +

Triangulations and Delaunay Triangulations

+ +

2D/3D Regular Triangulations

+ +
  • Weighted_point now has a constructor from Cartesian coordinates. +
+ +

3D Triangulations

+ +
  • Regular_triangulation_3 : semi-static floating-point filters are now used + in its predicates, which can speed up its construction by a factor of about 3 + when Exact_predicates_inexact_constructions_kernel is used. + +
  • The class Regular_triangulation_filtered_traits_3 is deprecated, the class + Regular_triangulation_euclidean_traits_3 must be used instead. The + predicates of that traits will be filtered if the kernel given as template + parameter of that traits is itself a filtered kernel. + +
  • Triangulation_hierarchy_3 is now deprecated, and replaced by a simpler + CGAL::Fast_location policy template parameter of Delaunay_triangulation_3. + +
  • The old version of remove() (enabled with CGAL_DELAUNAY_3_OLD_REMOVE) + has been deleted. +
+ +

3D Periodic Triangulations

+ +
  • New demo: 3D periodic Lloyd algorithm. + +
  • New functionality for Voronoi diagrams: dual of an edge and of a vertex, + volume and centroid of the dual of a vertex. + +
  • The package can now be used with the 3D Alpha Shapes package to compute + periodic alpha shapes. +
+ +

3D Alpha shapes

+ +
  • The class Weighted_alpha_shape_euclidean_traits_3 is deprecated, the class + Regular_triangulation_euclidean_traits_3 must be used instead. + +
  • The package can now be used together with the 3D Periodic Triangulation + package to compute periodic alpha shapes. +
+ +

2D/3D Triangulations, 2D Segment Delaunay Graph, 2D Apollonius Graph, + and 3D Periodic Triangulations

+ +
  • The constructor and insert function taking ranges now produce + structures whose iterator orders is now deterministic (same at each + run). +
+ + +

Mesh Generation

+ +

2D Mesh Generation

+ +
  • The 2D mesh generator can now be used with a constrained Delaunay + triangulation with constraints hierarchy + (Constrained_triangulation_plus_2). +
  • In some cases (refinement of a constrained edge that is on the + convex hull), the 2D mesh generator from CGAL-3.4 and CGAL-3.5 + could create invalid triangulations. This bug is now fixed. +
+ +

3D Mesh Generation

+ +
  • The mesh generator has been enriched with an optimization phase to + provide 3D meshes with well shaped tetrahedra (and in particular no + slivers). The optimization phase involves four different optimization + processes: two global optimization processes (ODT and Lloyd), a + perturber and an exuder. Each of these processes can be activated or + not, and tuned to the users needs and to available computer resources. +
+ +

Support library

+ +

CGAL ipelets

+ +
  • Add support for version 7 of Ipe. +
+ +
+ + +

Release 3.5.1

+
+

Release date: December 2009

+

+This is a bug fix release.

+ +

Documentation

+
    +
  • Fixes in the documentation (the online documentation of CGAL-3.5 is now + based on CGAL-3.5.1). +
  • Fixes to the bibliographic references. +
+ +

Windows installer

+
    +
  • The Windows installer of CGAL-3.5.1 fixes an issue with downloading of + precompiled binaries of the external library TAUCS. +
+ +

Bug fixes in the following CGAL packages

+

AABB tree

+
    +
  • Fix a linker issue in do_intersect(Bbox_3,Bbox_3). +
  • Fix compilation issue in do_intersect(Bbox_3,Ray_3) when using the + parameters in this order. +
+

3D Mesh Generation

+
    +
  • Fix a bug in initial points construction of a polyhedral surface. +
+
+ + + +

Release 3.5

+
+

Release date: October 2009

+

+ CGAL releases will now be published about every six months. As a transition + release, CGAL-3.5 has been developed during 9 months from the release + CGAL-3.4.

+ +

Version 3.5 differs from version 3.4 in the platforms that are supported and + in functionality. There have also been a number of bug fixes for this release.

+ +

General

+
    +
  • Additional supported platforms: +
      +
    • GNU g++ 4.4 supported. +
    • Intel Compiler 11 supported on Linux +
    +
  • Fixed ABI incompatibilities when mixing CGAL and Boost Program Options + on Windows/Visual C++ (the compilation flag -D_SECURE_SCL=0 is not + longer use in Debug mode). +
+ +

Geometry Kernels

+ +

3D Spherical Geometry Kernel

+
    +
  • + Add functionalities to manipulate circles, circular arcs and points + that belong to the same sphere. + +
+

Polygons

+ +

2D Regularized Boolean Set-Operations

+
    +
  • The polygon validation operations were enhanced and their interface was + improved. They are now offered as free functions and applied properly. + +
+

2D Straight Skeleton and Polygon Offsetting

+
    +
  • Updated the manual to document the new partial skeletons feature + (already in the code since 3.4) + +
+ +

Arrangements

+ +

2D Arrangements

+
    +
  • The member function is_at_infinity() of Arrangement_2::Vertex was + replaced by the new function is_at_open_boundary(). The former is + deprecated. While still supported in version 3.5, It will not be + supported in future releases. The member functions boundary_type_in_x() + and boundary_type_in_y() were permanently replaced by the functions + parameter_space_in_x() and parameter_space_in_y(), respectively. The 2 + new functions return an enumeration of a new type, namely + Arr_parameter_space. + +
  • The tags in the geometry traits that indicate the type of boundary of + the embedding surface were replaced by the following new tags: + Arr_left_side_tag + Arr_bottom_side_tag + Arr_top_side_tag + Arr_right_side_tag + In addition, the code was change, and now it is possible not to + indicate the tags at all. Default values are assumed. This however will + produce warning messages, and should be avoided. + +
  • All operations of the geometry traits-class were made 'const'. This + change was reflected in the code of this package and all other packages + that are based on it. Traits classes that maintain state, should + declare the data members that store the state as mutable. + +
+

Envelopes of Surfaces in 3D

+
    +
  • A few bugs in the code that computes envelopes were fixed, in + particular in the code that computes the envelopes of planes. + +
+ +

Triangulations and Delaunay Triangulations

+ +

3D Periodic Triangulations (new package)

+ +
    +
  • This package allows to build and handle triangulations of point sets in + the three dimensional flat torus. Triangulations are built + incrementally and can be modified by insertion or removal of + vertices. They offer point location facilities. + +
+ +

Mesh Generation

+ +

Surface Reconstruction from Point Sets (new package)

+
    +
  • This CGAL package implements an implicit surface reconstruction method: + Poisson Surface Reconstruction. The input is an unorganized point set + with oriented normals. + +
+

3D Mesh Generation (new package)

+
    +
  • This package generates 3 dimensional meshes. It computes isotropic + simplicial meshes for domains or multidomains provided that a domain + descriptor, able to answer queries from a few different types on the + domain, is given. In the current version, Mesh_3 generate meshes for + domain described through implicit functional, 3D images or polyhedral + boundaries. The output is a 3D mesh of the domain volume and conformal + surface meshes for all the boundary and subdividing surfaces. + +
+

Geometry Processing

+ +

Triangulated Surface Mesh Simplification

+ +
    +
  • BREAKING API change in the passing of the visitor object. + +
  • Fixed a bug in the link_condition test + +
  • Added a geometric test to avoid folding of facets + +
  • Fixed a bug in the handling of overflow in the LindstromTurk + computations + +
  • Updated the manual to account for the new visitor interface + +
+

Point Set Processing (new package)

+ +
    +
  • This packages implements a set of algorithms for analysis, processing, + and normal estimation and orientation of point sets. + +
+ +

Spatial Searching and Sorting

+ +

AABB tree (new package)

+ +
    +
  • This package implements a hierarchy of axis-aligned bounding boxes (a + AABB tree) for efficient intersection and distance computations between + 3D queries and sets of input 3D geometric objects. + +
+

Support Library

+ +

CGAL_ipelets (new package):

+
    +
  • Object that eases the writing of Ipe's plugins that use CGAL. + Plugins for CGAL main 2D algorithm are provided as demo. + + +
+
+ + +

Release 3.4

+
+

Release date: January 2009

+ +

Version 3.4 differs from version 3.3.1 in the platforms that are supported and +in functionality. There have also been a number of bug fixes for this release. +

+ +

General

+
    +
  • GNU g++ 4.3 supported. Support for g++ 3.3 is dropped. +
  • Visual 9 supported. Support for Visual 7 is dropped. + +
  • Boost version 1.33 at least is now required. +
  • CGAL now depends on Boost.Threads, which implies to link against + a compiled part of Boost. + +
  • The new macro CGAL_NO_DEPRECATED_CODE can be defined to disable deprecated code, + helping users discover if they rely on code that may be removed in + subsequent releases. + +
  • Assertion behaviour: + It is not possible anymore to set the CONTINUE mode for assertion failures. + Functions that allow to change the assertion behaviour are now declared in <CGAL/assertions_behaviour.h>. + +
  • Qt3 based demos are still there but the documentation has been removed as the CGAL::Qt_Widget will be deprecated. + +
  • Qt4 based demos use the Qt GraphicsView framework and the libQGLViewer. +
+ +

Installation

+ +
    +
  • install_cgal has been replaced by CMake. +
+ + +

Polynomial (new package)

+
    +
  • This package introduces a concept Polynomial_d, a concept for multivariate polynomials in d variables. +
+ + +

Modular Arithmetic (new package)

+
    +
  • This package provides arithmetic over finite fields. +
+ + +

Number Types

+
    +
  • the counter Interval_nt::number_of_failures() has been removed, replaced by + a profiling counter enabled with CGAL_PROFILE. + + +
  • Fix of a bug in CORE/Expr.h; as a consequence, the arrangement demo works properly when handling + arrangements of conics, for example, when defining an arc with 5 points. + +
+ + + +

3D Spherical Geometry Kernel (new package)

+
    +
  • This package is an extension of the linear CGAL Kernel. It offers functionalities on spheres, + circles, circular arcs and line segments in the 3D space. +
+ +

Linear Kernel

+
    +
  • We recommend that you use the object_cast() function instead of assign() + to extract an object from a CGAL::Object, for efficiency reasons. +
  • The Kernel archetypes provided by the 2D/3D linear kernel have been removed. +
  • The deprecated linear kernel functors Construct_supporting_line_2 and + Construct_supporting_line_3 have been removed. +
  • Ambiant_dimension and Feature_dimenison have been added to retrieve the + potentially compile-time dimension of a space or of an object. +
  • barycenter() functions have been added. + +
  • The geometric object Circle_3 as well as predicates and constructions have been added to the kernel + +
  • The missing intersection/do_intersect between Line_3 and Line_3 has been added as well. +
+ + +

3D Triangulations

+
    +
  • Removed the deprecated functions Cell:mirror_index() and Cell::mirror_vertex(). +
  • Derecursification of two functions that in some cases lead to stack overflows +
+ + +

3D Nef Polyhedron

+
    +
  • n-ary union/intersection +
  • intersection with halfspace under standard kernel +
  • constructor for polylines +
+ + +

CGAL and the Qt4 GraphicsView (new package)

+
    +
  • 2D CGAL Kernel objects and many data structures have can be rendered in a QGraphicsView +
+ +

STL Extensions:

+
    +
  • The functor adaptors for argument binding and composition + (bind_*, compose, compose_shared, swap_*, negate, along with the helper + functions set_arity_* and Arity class and Arity_tag typedefs) which were provided + by <CGAL/functional.h> have been removed. Please use the better boost::bind + mecanism instead. The concept AdaptableFunctor has been changed accordingly + such that only a nested result_type is required. +
  • The accessory classes Twotuple, Threetuple, Fourtuple and Sixtuple are also + deprecated (use CGAL::array instead). +
  • CGAL::Triple and CGAL::Quadruple are in the process of being replaced by + boost::tuple. As a first step, we strongly recommend that you replace + the direct access to the data members (.first, .second, .third, .fourth), + by the get<i>() member function; and replace the make_triple and make_quadruple + maker functions by make_tuple.
    + This way, in a further release, we will be able to switch to boost::tuple more easily. +
  • The class CGAL::Uncertain<> has been documented. It is typically used to report + uncertain results for predicates using interval arithmetic, and other filtering + techniques. +
+ + +

2D Arrangements

+
    +
  • Changed the name of the arrangement package from Arrangement_2 to Arrangement_on_surface_2 + to reflect the potential capabilities of the package to construct and maintain arrangements + induced by curves embedded on two dimensional surfaces in three space. Most of these capabilities + will become available only in future releases though. +
  • Enhanced the geometry traits concept to handle arrangements embedded on surfaces. Each geometry-traits + class must now define the 'Boundary_category' tag. +
  • Fixed a bug in Arr_polyline_traits_2.h, where the operator that compares two curves failed to evaluate + the correct result (true) when the curves are different, but their graphs are identical. +
  • Permanently removed IO/Arr_postscript_file_stream.h and IO/Polyline_2_postscript_file_stream.h, + as they depend on obsolete features and LEDA. +
  • Fixed several bugs in the arrangement demo and enhanced it. e.g., fixed background color change, + allowed vertex coloring , enabled "smart" color selection, etc. +
  • Enhanced the arrangement demo with new features, such as allowing the abortion of the merge function + (de-select), updated the how-to description, etc. +
  • Replace the functions CGAL::insert_curve(), CGAL::insert_curves(), CGAL::insert_x_monotone_curve(), + and CGAL::insert_x_monotone_curves() with a single overloaded function CGAL::insert(). The former + 4 functions are now deprecated, and may no longer be supported in future releases. +
+ +

Envelopes of Surfaces in 3D

+ +
    +
  • Fixed a bug in the computation of the envelope of unbounded planes caused by multiple removals + of vertices at infinity. +
+ +

2D Regularized Boolean Set-Operations

+
    +
  • Fixed a bug in connect_holes() that caused failures when connecting holes touching the outer boundary. +
  • Fixed the concept GeneralPolygonSetTraits_2. Introduced two new concepts GpsTraitsGeneralPolygon_2 + and GpsTraitsGeneralPolygonWithHoles_2. Fixed the definition of the two nested required types Polygon_2 + and Polygon_with_holes_2 of the GeneralPolygonSetTraits_2 concept. They must model now the two new + concepts above. +
  • Added a default template parameter to 'General_polygon_set_2' to allow users to pass their specialized + DCEL used to instantiate the underlying arrangement. +
  • Enhanced the BOP demo to use multiple windows. +
+ +

2D Minkowski Sums

+
    +
  • Fixed a few bugs in the approximate offset function, making it robust to highly degenerate inputs. +
  • Fixed a bug in the exact Minkowski sum computation when processing degenerate inputs that induce overlapping + of contiguous segments in the convolution cycles. +
  • Optimized the approximate offset function (reduced time consumption up to a factor of 2 in some cases). +
  • Added functionality to compute the offset (or to approximate the offset) of a Polygon_with_holes_2 + (and not just of a Polygon_2). +
  • Added the functionality to compute (or to approximate) the inner offset of a polygon. +
+ +
+ + +

Release 3.3.1

+
+

Release date: August 2007

+ +

This is a bug fix release. +

+ +

General

+
    +
  • Intel C++ 9 was wrongly recognized as unsupported by install_cgal. +
  • Added autolink (for Visual C++) for the CGALImageIO and CGALPDB libraries. +
  • Fixed bug in Memory_sizer when using more than 4GB of memory (64bit). +
+ +

Number Types

+
    +
  • Fixed bug in FPU rounding mode macros (affected only the alpha architecture). +
  • Fixed bug in MP_Float constructor from double for some particular values. +
  • Fixed bug in to_double(Lazy_exact_nt) sometimes returning NaN. +
+ +

Kernel

+
    +
  • Fixed forgotten derivation in Circular_kernel_2::Has_on_2 +
  • Added some missing functions in Bbox_3 compared to Bbox_2. +
+ +

Skin Surface Meshing

+
    +
  • The new Skin Surface Meshing package had been forgotten in the list of + changes and the release announcement of CGAL 3.3: + This package allows to build a triangular mesh of a skin surface. + Skin surfaces are used for modeling large molecules in biological computing. +
+ +

Arrangements

+
    +
  • Fixed a bug in the Arrangement_2 package in dual arrangement representation + for Boost graphs when reporting all halfedges of a face. +
  • Fixed a bug in the Arrangement sweep-line when using a specific polyline + configuration. +
  • Fixed bug in Arrangement_2 in walk along a line point location for unbounded curves. +
  • Fixed bug in aggregated insertion to Arrangement_2. +
  • Fixed bug in Arrangment_2 class when inserting an unbounded curve from an existing vertex. +
  • Fixed bug when dealing with a degenerate conic arc in Arr_conic_traits_2 of + the Arrangment package, meaning a line segment which is part of a degenerate + parabola/hyperbola. +
  • Fixed bug in the Bezier traits-class: + properly handle line segments. + properly handle comparison near a vertical tangency. +
+ +

2D Polygon

+
    +
  • Fixed bug in degenerate case of Polygon_2::is_convex() for equal points. +
+ +

2D Triangulations

+
    +
  • Fixed bug in Regular_triangulation_2. +
+ +

3D Triangulations

+
    +
  • Added a circumcenter() function in the default Cell type parameter + Triangulation_ds_cell_base_3, so that the .dual() member function of + Delaunay still work as before, without requiring the explicit use of + Triangulation_cell_base. +
  • Added missing operator->() to Facet_circulator. +
+ +

Interpolation

+
    +
  • Fixed bug in Interpolation 3D about the normalization coefficient initialization. +
+ +

3D Boolean Operations on Nef Polyhedra

+
    +
  • Fixed bug in construction of Nef_polyhedron_3 from off-file. Now, always the + inner volume is selected. +
  • Fixed bug in conversion from Nef_polyhedron_3 to Polyhedron_3. Polyhedron_3 was not cleared + at the beginning. +
  • Fixed bug in Nef_polyhedron_3 in update of indexes for construction of external structure. +
+ +

Third Party Libraries Shipped with CGAL

+
    +
  • TAUCS supports now 64 bits platforms. +
  • CAUTION: Since version 3.3.1, CGAL is no longer compatible with the official + release of TAUCS (currently 2.2). Make sure to use the version + modified by the CGAL project and available from the download section + of http://www.cgal.org. +
+ +
+ + + +

Release 3.3

+
+

Release date: May 2007

+ +

+Version 3.3 differs from version 3.2.1 in the platforms that are supported and +in functionality. There have also been a number of bug fixes for this release. +

+ +

Additional supported platforms +

    +
  • GNU g++ 4.1 and 4.2 +
  • Intel C++ compiler 9 +
  • Microsoft Visual C++ compiler 8.0 +
+ +

The following platforms are no longer supported: + +

    +
  • Intel 8 +
+ +

CGAL now supports Visual C++ "Checked iterators" as well as the debug mode +of GNU g++'s STL (-D_GLIBCXX_DEBUG).

+ +

CGAL now works around the preprocessor macros 'min' and 'max' defined +in <windows.h> which were clashing with min/max functions. +

+ + +

Installation

+ +
    +
  • On Windows the libraries built in Developer Studio now have names + which encode the compiler version, the runtime and whether it was + built in release or debug mode. The libraries to link against are + chosen with linker pragmas in header files. +
  • On all platforms but Windows shared and static versions of the libraries are generated +
+ +

Manuals

+
    +
  • The Package Overview page now also hosts the precompiled demos. +
+ +

Algebraic Foundations

+ + +

+

    +
  • Algebraic Foundations (new package)
    + +This package defines what algebra means for CGAL, in terms of concepts, classes and functions. The main features are: (i) explicit concepts for interoperability of types (ii) separation between algebraic types (not necessarily embeddable into the reals), and number types (embeddable into the reals). + +

    +

  • Number Types
    + Fixed_precision_nt and Filtered_exact number types have been removed. +
+ +

Kernels

+ +

+

    +
  • 2D Circular Kernel
    +Efficiency improved through geometric filtering of predicates, introduced with + the filtered kernel Filtered_bbox_circular_kernel_2<.>, and also chosen for the + predefined kernel Exact_circular_kernel_2. + +
  • Linear Kernel
    + Exact_predicates_exact_constructions_kernel memory and run-time improvements + through usage of lazy geometric constructions instead of lazy arithmetic. +
+ +

Data Structures and Algorithms

+ +

+

    +
  • Surface Mesh Simplification (new package)
    + + This package provides a mesh simplification framework using edge collapse + operations, and provides the Turk/Lindstrom simplification algorithm. + +

    +

  • Skin Surface Meshing (new package)
    + + This package allows to build a triangular mesh of a skin surface. + Skin surfaces are used for modeling large molecules in biological + computing. The surface is defined by a set of balls, representing + the atoms of the molecule, and a shrink factor that determines the + size of the smooth patches gluing the balls together. + +

    +

  • Estimation of Local Differential Properties (new package)
    + + This package allows to compute local differential quantities of a surface from a point sample + +

    +

  • Approximation of Ridges and Umbilics on Triangulated Surface Meshes (new package)
    + + This package enables the approximation of differential features on + triangulated surface meshes. Such curvature related features are + lines: ridges or crests, and points: umbilics. + +

    +

  • Envelopes of Curves in 2D (new package)
    + + This package contains two sets of functions that construct the lower and upper envelope diagram + for a given range of bounded or unbounded curves. + +

    +

  • Envelopes of Surfaces in 3D (new package)
    + + This package contains two sets of functions that construct the lower and upper envelope diagram + for a given range of bounded or unbounded surfaces. The envelope diagram is realized as a + 2D arrangement. + +

    +

  • Minkowski Sums in 2D (new package)
    + + This package contains functions for computing planar Minkowski sums of two closed polygons, + and for a polygon and a disc (an operation also known as offsetting or dilating a polygon). + The package also contains an efficient approximation algorithm for the offset computation, + which provides a guaranteed approximation bound while significantly expediting the running + times w.r.t. the exact computation procedure. + +

    +

  • Surface Mesh Parametrization
    + + Added Jacobi and SSOR preconditioners to OpenNL solver, which makes it + much faster and more stable. + +

    +

  • 2D Arrangements
    + +
      +
    • Added support for unbounded curves. +
    • Added a traits class that supports bounded and unbounded linear objects, + namely lines, rays and line segments. +
    • Added traits classes that handle circular arcs based on the circular kernel. +
    • Added a traits class that supports Bezier curves. +
    • Enhanced the traits class that supports rational functions to + handle unbounded (as well as bounded) arcs +
    • Added a free function called decompose() that produces the symbolic vertical decomposition of a + given arrangement, performing a batched vertical ray-shooting query from all arrangement vertices. +
    • Fixed a memory leak in the sweep-line code. +
    • Fixed a bug in computing the minor axis of non-degenerate hyperbolas. +
    + +
  • Boolean Set Operations
    +
      +
    • Added the DCEL as a default template parameter to the General_polygon_set_2 and Polygon_set_2 classes. + This allows users to extend the DCEL of the underlying arrangement. +
    • Added a function template called connect_holes() that connects the holes in a given polygon with holes, + turning it into a sequence of points, where the holes are connceted to the outer boundary using + zero-width passages. +
    • Added a non-const function member to General_polygon_set_2 that obtains the underlying arrangement. +
    + +

    +

  • 2D and 3D Triangulations
    +
      +
    • The constructors and insert member functions which take an iterator range perform spatial sorting + in order to speed up the insertion. +
    + + +

    +

  • Optimal Distances +
    +
      +
    • Polytope_distance_d: + has support for homogeneous points; bugfix in fast exact version. +
    + + +

    +

  • Bounding Volumes +
    +
      +
    • Min_annulus_d has support for homogeneous points; bugfix in fast exact version. +
    + +
+ +

Support Library

+ +
    +
  • CGAL and the Boost Graph Library (BGL) (new package)
    + +This package provides the glue layer for several CGAL data structures such that +they become models of the BGL graph concept. + +

    +

  • Spatial Sorting (new package)
    + +This package allows to sort points and other objects along a Hilbert curve +which can improve the performance of algorithms like triangulations. +It is used by the constructors of the triangulation package which have +an iterator range of points as argument. + +

    +

  • Linear and Quadratic Programming Solver (new package)
    +This package contains algorithms for minimizing linear and +convex quadratic functions over polyhedral domains, described by linear +equations and inequalities. +
+
+ + + + + +

Release 3.2.1

+
+

Release date: July 2006

+ +

+This is a bug fix release +

+ +

Number Types

+
    +
  • Fix MP_Float constructor which crashed for some values. +
+ +

Kernel

+
    +
  • Rename Bool to avoid a clash with a macro in X11 headers. +
+

Arrangement

+ +
    +
  • Derived the Arr_segment_traits_2 Arrangement_2 traits class from the parameterized Kernel. + This allows the use of this traits class in an extended range of applications that require + kernel objects and operations on these objects beyond the ones required by the Arrangement_2 + class itself. +
  • Fixed a compilation bug in the code that handles overlay of arrangements instantiated with + different DCEL classes. +
  • Fixed a couple of bugs in the implementation of the Trapezoidal RIC point-location strategy +
+ +

Triangulation, Alpha Shapes

+
    +
  • Qualify calls to filter_iterator with "CGAL::" to avoid overload ambiguities with + Boost's filter_iterator. +
+ +

Surface Mesher

+
    +
  • Fixed a bug in iterators of the class template Surface_mesh_complex_2_in_triangulation_3 +
+ +

Surface Mesh Parametrisation

+
    +
  • Updated the precompiled taucs lib +
+

Kinetic Data Structures

+
    +
  • Fixed problems caused by old versions of gcc being confused by operator! and operator int() +
  • Added point removal support to the Active_objects_vector +
+ +
+ + +

Release 3.2

+
+

Release date: May 2006

+ +

+Version 3.2 differs from version 3.1 in the platforms that are supported and +in functionality. There have also been a number of bug fixes for this release. +

+ +

The following platforms are no longer supported: + +

    +
  • SunPro CC versions 5.4 and 5.5 on Solaris +
  • SGI Mips Pro +
+ +

+For Visual C++ the installation scripts choose the multi-threaded dynamically +linked runtime (/MD). Before it was the single-threaded static runtime (/ML).

+ + +

Installation

+ +
    +
  • The install tool tries to find third party libraries + at "standard" locations. +
  • Installers for Apple, Windows, and rpms. +
+ +

Manuals

+
    +
  • User and Reference manual pages of a package are in the same chapter +
+ + +

Kernels

+ +

+

    +
  • 2D Circular Kernel (new package)
    +This package is an extension of the linear CGAL Kernel. It offers functionalities +on circles, circular arcs and line segments in the plane. +
+ +

Data Structures and Algorithms

+ +

+

    +
  • 2D Regularized Boolean Set-Operations (new package)
    + +This package consists of the implementation of Boolean set-operations +on point sets bounded by weakly x-monotone curves in 2-dimensional +Euclidean space. In particular, it contains the implementation of +regularized Boolean set-operations, intersection predicates, and point +containment predicates. + +

    +

  • 2D Straight Skeleton and Polygon Offsetting (new package)
    + +This package implements an algorithm to construct a halfedge data +structure representing the straight skeleton in the interior of 2D +polygons with holes and an algorithm to construct inward offset +polygons at any offset distance given a straight skeleton. + + +

    +

  • 2D Voronoi Diagram Adaptor (new package)
    + +This package provides an adaptor that adapts a +2-dimensional triangulated Delaunay graph to the corresponding +Voronoi diagram, represented as a doubly connected edge list (DCEL) +data structure. The adaptor has the ability to automatically +eliminate, in a consistent manner, degenerate features of the Voronoi +diagram, that are artifacts of the requirement that Delaunay graphs +should be triangulated even in degenerate configurations. Depending on +the type of operations that the underlying Delaunay graph supports, +the adaptor allows for the incremental or dynamic construction of +Voronoi diagrams and can support point location queries. + + +

    +

  • 3D Surface Mesher (new package)
    + +This package provides functions to generate surface meshes that +interpolate smooth surfaces. The meshing algorithm is based on +Delaunay refinement and provides some guarantees on the resulting +mesh: the user is able to control the size and shape of the mesh +elements and the accuracy of the surface approximation. There is no +restriction on the topology and number of components of input +surfaces. The surface mesher may also be used for non smooth surfaces +but without guarantee. + +

    +Currently, implementations are provided for implicit surfaces +described as the zero level set of some function and surfaces +described as a gray level set in a three-dimensional image.

    + + +

    +

  • 3D Surface Subdivision Methods (new package)
    + +Subdivision methods recursively refine a control mesh and generate +points approximating the limit surface. This package consists of four +popular subdivision methods and their refinement hosts. Supported +subdivision methods include Catmull-Clark, Loop, Doo-Sabin and sqrt(3) +subdivisions. Their respective refinement hosts are PQQ, PTQ, DQQ and +sqrt(3) refinements. Variations of those methods can be easily +extended by substituting the geometry computation of the refinement +host. + + +

    +

  • Planar Parameterization of Triangulated Surface Meshes (new package)
    + +Parameterizing a surface amounts to finding a one-to-one mapping from +a suitable domain to the surface. In this package, we focus on +triangulated surfaces that are homeomorphic to a disk and on piecewise +linear mappings into a planar domain. This package implements some of +the state-of-the-art surface mesh parameterization methods, such as +least squares conformal maps, discrete conformal map, discrete +authalic parameterization, Floater mean value coordinates or Tutte +barycentric mapping. + + +

    +

  • Principal Component Analysis (new package)
    + +This package provides functions to compute global informations on the +shape of a set of 2D or 3D objects such as points. It provides the +computation of axis-aligned bounding boxes, centroids of point sets, +barycenters of weighted point sets, as well as linear least squares +fitting for point sets in 2D, and point sets as well as triangle sets +in 3D. + + +

    +

  • 2D Placement of Streamlines (new package)
    + +Visualizing vector fields is important for many application domains. A +good way to do it is to generate streamlines that describe the flow +behaviour. This package implements the "Farthest Point Seeding" +algorithm for placing streamlines in 2D vector fields. It generates a +list of streamlines corresponding to an input flow using a specified +separating distance. The algorithm uses a Delaunay triangulation to +model objects and adress different queries, and relies on choosing the +centers of the biggest empty circles to start the integration of the +streamlines. + + +

    +

  • Kinetic Data Structures (new package)
    + +Kinetic data structures allow combinatorial structures to be +maintained as the primitives move. The package provides +implementations of kinetic data structures for Delaunay triangulations +in two and three dimensions, sorting of points in one dimension and +regular triangulations in three dimensions. The package supports exact +or inexact operations on primitives which move along polynomial +trajectories. + + +

    +

  • Kinetic Framework (new package)
    + +Kinetic data structures allow combinatorial geometric structures to be +maintained as the primitives move. The package provides a framework to +ease implementing and debugging kinetic data structures. The package +supports exact or inexact operations on primitives which move along +polynomial trajectories. + + +

    +

  • Smallest Enclosing Ellipsoid (new package)
    + +This algorithm is new in the chapter Geometric Optimisation. + +

    +

  • 2D Arrangement (major revision)
    + +This package can be used to construct, maintain, alter, and display +arrangements in the plane. Once an arrangement is constructed, the +package can be used to obtain results of various queries on the +arrangement, such as point location. The package also includes generic +implementations of two algorithmic frameworks, that are, computing the +zone of an arrangement, and line-sweeping the plane, the arrangements +is embedded on. + +

    +Arrangements and arrangement components can also be extended to store +additional data. An important extension stores the construction +history of the arrangement, such that it is possible to obtain the +originating curve of an arrangement subcurve.

    + + +

    +

  • Geometric Optimisation (major revision)
    + +The underlying QP solver which is the foundation for several algorithms +in the Geometric Optimisation chapter has been completely rewritten. + +

    +

  • 3D Triangulation (new functionality)
    + +Regular_triangulation_3 now offers vertex removal. + +
+ + +
+ +

Release 3.1

+
+

Release date: December 2004

+

Version 3.1 differs from version 3.0 in the platforms that are supported and +in functionality. There have also been a number of bug fixes for this release.

+ + +

+Additional supported platforms: +

    +
  • MS Visual C++, version 7.3. and 8.0 +
  • Intel 8.0 +
  • SunPro CC versions 5.4 and 5.5 on Solaris +
  • GNU g++ versions 3.4 on Linux, Solaris, Irix, cygwin, FreeBSD, and MacOS X +
  • Darwin (MacOS X) and IA64/Linux support. +
+

+The following platforms are no longer supported: +

    +
  • MS Visual C++, version 7.0 +
+ +

+The following functionality has been added or changed:

+ +

All

+
    +
  • The CORE 1.7 library for exact + real arithmetic. +
  • Updated GMP to 4.1.3. +
  • Added Mpfr a library for multiple-precision floating-point computations with exact rounding. +
  • Added Boost 1.32.0 (only include files). +
+ +

Installation

+
    +
  • new option --disable-shared to omit building libCGAL.so. +
+ + +

Manuals

+
    +
  • Merged all major manuals in one multi-part manual, which provides + now cross-links between the CGAL Kernel, the CGAL Basic Library, + and the CGAL Support Library HTML manuals. + +
  • Improved layout. +
+ +

Kernels

+ +
    +
  • Improved efficiency of filtered kernels. +
  • More predicates and constructions. +
+ + +

Basic Library

+ + +
    +
  • 2D Segment Voronoi Diagram (new package)
    + +A data structure for Voronoi diagrams of segments in the plane under the Euclidean metric. The Voronoi edges +are arcs of straight lines and parabolas. The algorithm provided in this package is incremental. +
    • + +
  • 2D Conforming Triangulations and Meshes (new package)
    + +An implementation of Shewchuk's algorithm to construct conforming triangulations and 2D meshes. +
    • + + + +
  • 3D Boolean Operations on Nef Polyhedra (new package)
    +A new class (Nef_polyhedron_3) representing 3D Nef polyhedra, a + boundary representation for cell-complexes bounded by halfspaces + that supports boolean operations and topological operations in full + generality including unbounded cells, mixed dimensional cells (e.g., + isolated vertices and antennas). Nef polyhedra distinguish between + open and closed sets and can represent non-manifold geometry. + +
    • + +
  • 2D and Surface Function Interpolation (new package)
    + +This package implements different methods for scattered data interpolation: Given +measures of a function on a set of discrete data points, the task is +to interpolate this function on an arbitrary query point. The package +further offers functions for natural neighbor interpolation. + +
    • + +
  • Planar Nef polyhedra embedded on the sphere (new package)
    + A new class (Nef_polyhedron_S2) designed and supported mainly to + represent sphere neighborhoods around vertices of the three- + dimensional Nef polyhedra. +
    • + +
  • Box_intersection_d (new package)
    + + A new efficient algorithm for finding all intersecting pairs for + large numbers of iso-oriented boxes, i.e., typically these will be + bounding boxes of more complicated geometries. Useful for (self-) + intersection tests of surfaces etc. +
    • + + +
  • 2D Snap Rounding (new package)
    + +Snap Rounding is a well known method for converting +arbitrary-precision arrangements of segments into a fixed-precision +representation. In the study of robust geometric +computing, it can be classified as a finite precision approximation +technique. Iterated Snap Roundingis a modification +of Snap Rounding in which each vertex is at least half-the-width-of-a-pixel away +from any non-incident edge. This package supports both +methods. +
    • + +
  • 3D Triangulations + +
      +
    • Triangulation_3: added operator==(),removed push_back() and copy_triangulation(). +
    • Delaunay_3 : added nearest_vertex(), move_point(), vertices_in_conflict(). +
    • Regular_3 : added filtered traits class, and nearest_power_vertex(). +
    + + +
  • Planar_map and Arrangement_2 + +
      +
    • The interface of the two traits functions that compute the intersection of two given curves changed. The functions nearest_intersection_to_right() and nearest_intersection_to_left() return an object of type CGAL::Object that represents either an empty intersection, a point, or an overlapping subcurve. +
    • Requirements to define two binary tags were added to the traits concept of the Planar_map as follows: +Has_left_category - indicates whether the functions curves_compare_y_at_x_left() and nearest_intersection_to_left() are implemented in the traits model. +Has_reflect_category - indicates whether the functions point_reflect_in_x_and_y() and curve_reflect_in_x_and_y() are implemented in the traits model. They can be used as an alternative to the two function in the previous item. +
    • A new constructor of the Segment_cached_2 type that represents a segment in the Arr_segment_cached_traits_2 traits class was introduced. The new constructor accepts the segment endpoints as well as the coefficients of the underlying line. +
    • A new version of the conic-arc traits, based on CORE version 1.7 was introduced. This new traits class makes use of CORE's rootOf() operator to compute the intersection points in the arrangement, making its code much simpler and more elegant than the previous version. In addition, new constructors for conic arcs are provided. The new traits class usually performs about 30% faster than the version included in CGAL 3.0 +
    • The traits class that handles continuous piecewise linear curves, namely Arr_polyline_traits_2, was rewritten. The new class is parametrized with a traits class that handles segments, say Segment_traits. The polyline curve defined within the Arr_polyline_traits_2 class is implemented as a vector of segments of type Segment_traits::Curve_2. +
    • A meta traits class, namely Arr_curve_data_traits_2, that extends the curve type of the planar-map with arbitrary additional data was introduced. It should be instantiated with a regular traits-class and a class that contains all extraneous data associated with a curve. +
    • The class that represents the trapezoidal-decomposition point location strategy was renamed to Pm_trapezoid_ric_point_location. +
    • The Arrangement demo was rewritten. It covers many more features, has a much better graphical user interface, and comes with online documentation. +
    • Few bugs in the sweep-line module related to overlapping vertical segments were fixed. This module is used by the aggregate insert method that inserts a collection of curves at once. +
    + + +
  • Triangulation_2 + +
      +
    • added a filtered trait class in the regular triangulation +
    • added split and join operations in the triangulation data structure class +
    + +
  • Alpha_shapes_3 + +
      +
    • major changes in the implementation of the class Alpha_shapes_3. +
    • New implementation results in a true GENERAL mode + allowing null and negative alpha-values. It also fixed the edges classification bug + and introduces a classification of vertices. +
    + +
  • Min_ellipse_2 + +
      +
    • made access to approximate double representation public +
    • fixed bugs in conversion to double representation +
    • added is_circle() method +
    • minor performance improvements +
    + +
  • Min_sphere_of_spheres_d: + +
      +
    • The models + + Min_sphere_of_spheres_d_traits_2<K,FT,UseSqrt,Algorithm>, + Min_sphere_of_spheres_d_traits_3<K,FT,UseSqrt,Algorithm>, and + Min_sphere_of_spheres_d_traits_d<K,FT,Dim,UseSqrt,Algorithm> + + of concept MinSphereOfSpheresTraits now represent a sphere + as a std::pair<Point,Radius> (and not any more as a + CGAL::Weighted_point<Point,Weight>) +
    • Internal code cleanup; in particular, implementation details + don't pollute the namespace CGAL anymore +
    + + +
  • Polyhedron_3 + +
      +
    • New Tutorial on CGAL Polyhedron for Subdivision Algorithms with + interactive demo viewer in source code available. + +
    • Added example program for efficient self-intersection test. + - Added small helper functions, such as vertex_degree, facet_degree, + edge_flip, and is_closed. +
    + +
  • Apollonius Graph (Voronoi of Circles) + +
      +
    • Reduced memory requirements by approximately a factor of two. +
    + +
+ +
+ + +

Release 3.0.1

+
+

Release date: February 2004

+ +

This is a bug-fix release. +No new features have been added in 3.0.1. Here is the list of bug-fixes.

+ +

Polyhedral Surface

+ +
    +
  • Fixed wrong include files for output support. Added example. +
+ +

Planar_map

+ +
    +
  • Fixed the so called "Walk-along-a-line" point-location strategy to + correctly handle a degenerate case. +
+ +

2D Triangulation

+ +
    +
  • added missing figure in html doc +
  • in Line_face_circulator_2.h:
    + Fixed changes made to support handles with a typedef to iterator. + The fix concerns operator== and !=. +
+ +

Alpha_shapes_3

+ +
    +
  • fixed classify member function for edges. +
+ + +

Number types

+ +
    +
  • Lazy_exact_nt: +
      +
    • added the possibility to select the relative precision of + to_double() (by default 1e-5). This should fix reports + that some circumcenters computations have poor coordinates, + e.g. nan). +
    • when exact computation is triggered, the interval is recomputed, + this should speed up some kinds of computations. +
    +
  • to_interval(Quotient<MP_Float>): avoid spurious overflows. +
+ +

Kernel

+ +
    +
  • + missing acknowledgment in the manual and minor clarification of + + intersection() documentation. +
+ +
+ +

Release 3.0

+
+ +

Release date: October 2003

+ +

Version 3.0 differs from version 2.4 in the platforms that are supported and +in functionality. There have also been a number of bug fixes for this release.

+ +

The license has been changed to either the LGPL (GNU Lesser General Public +License v2.1) or the QPL (Q Public License v1.0) depending on each package. +So CGAL remains free of use for you, if your usage meets the criteria of these +licenses, otherwise, a commercial license has to be purchased from +GeometryFactory.

+ +

+Additional supported platforms: +

    +
  • MS Visual C++, version 7.1. +
  • SunPro CC versions 5.4 and 5.5 on Solaris +
  • GNU g++ versions 3.2 and 3.3 on Linux, Solaris, Irix, cygwin, and FreeBSD. +
  • MipsPRO CC 7.30 and 7.40 with both the n32 and n64 ABIs. +
+

+The following platforms are no longer supported: +

    +
  • MS Visual C++, version 6. +
  • GNU g++ 2.95.2 (2.95.3 is still supported) +
  • Kai C++ and Borland C++, all versions +
+ +

+The following functionality has been added or changed:

+ +All +

    +
  • The CORE library for exact + computations is now distributed as part of CGAL as well. +
+ + +

Kernels

+ + +
    +
  • 3 typedefs have been added to ease the choice of a robust and fast kernel: +
      +
    • Exact_predicates_inexact_constructions_kernel +
    • Exact_predicates_exact_constructions_kernel +
    • Exact_predicates_exact_constructions_kernel_with_sqrt +
    +
  • Progress has been made towards the complete adaptability and + extensibility of our kernels. +
  • New faster Triangle_3 intersection test routines. +
    (see Erratum) +
  • Added a Kernel concept archetype to check that generic algorithms + don't use more functionality than they should. +
  • A few more miscellaneous functions. +
+ +

Basic Library

+ +
    +
  • 2D Apollonius Graph (new package)
    +Algorithms for computing the Apollonius + graph in two dimensions. The Apollonius graph is the dual of the + Apollonius diagram, also known as the additively weighted Voronoi + diagram. The latter can be thought of as the Voronoi diagram of a set + of circles under the Euclidean metric, and it is a generalization of the + standard Voronoi diagram for points. The algorithms provided are + dynamic. + +
  • dD Min Sphere of Spheres (new package)
    + Algorithms to compute the smallest + enclosing sphere of a given set of spheres in Rd. + The package provides + an algorithm with maximal expected running time + O(2O(d) n) and a + fast and robust heuristic (for dimension less than 30). + +
  • Spatial Searching (new package)
    +Provides exact and approximate distance + browsing in a set of points in d-dimensional space using + implementations of algorithms supporting: +
      +
    • both nearest and furthest neighbor searching +
    • both exact and approximate searching +
    • (approximate) range searching +
    • (approximate) k-nearest and k-furthest neighbor + searching +
    • (approximate) incremental nearest and incremental furthest neighbor + searching +
    • query items representing points and spatial objects. +
    + +
  • Kd-tree
    +this package is deprecated, its documentation is removed. + It is replaced by the Spatial Searching package. + +
  • Largest_empty_rectangle_2
    + Given a set of points P in the plane, the class + Largest_empty_iso_rectangle_2 is a data structure that + maintains an iso-rectangle with the largest area among all + iso-rectangles that are inside a given iso-rectangle bounding box, + and that do not contain any point of the point set P. + +
  • 2D Triangulation and + 3D Triangulation
    +
      +
    • The classes Triangulation_data_structure_2 (and 3), which implements + the data structure for 2D triangulation class, now makes use of + CGAL::Compact_container (see Support Library section below). +
    • The triangulation classes use a Rebind mecanism to provide + the full flexibility on Vertex and Face base classes. + This means that it is possible for the user to derive its own Face + of Vertex base class, adding a functionality that makes use of + types defined by the triangulation data structure like Face_handle + or Vertex_handle. +
    • New classes Triangulation_vertex_base_with_info_2 (and 3) and + Triangulation_face_base_with_info_2 (and 3) to make easier the + customisation of base classes in most cases. +
    + +
  • 2D Triangulation
    +
      +
    • Regular triangulation provides an easy access to hidden points. +
    • The Triangulation_hierarchy_2, which provide an efficient location + data structure, can now be used with any 2D triangulation class plugged + in (including Regular triangulations). +
    + +
  • 3D Triangulation
    +
      +
    • faster vertex removal function in Delaunay_triangulation_3. +
    • Delaunay_triangulation_3 is now independent of the order of insertions + of the points (in case of degenerate cosphericity). +
    • Regular_triangulation_3 now hides vertices (and updates itself) when + inserting a coinciding point with greater weight. This required a new + predicate. +
    • deprecated functions: copy_triangulation(), push_back(), + set_number_of_vertices(). +
    • Triangulation_3 now gives non-const access to the data structure. +
    + +
  • Interval Skip List (new package)
    +An interval skip list is a data strucure for finding all intervals + that contain a point, and for stabbing queries, that is for answering + the question whether a given point is contained in an interval or not. + +
  • + Planar Maps and + + Arrangements
    + + The changes concern mainly the traits classes. +
      +
    1. New traits hierarchy and interface: + The set of requirements was made sound and complete. A couple of + requirements were eliminated, few others were redefined, and some + were renamed. A hierarchy of three traits classes for the + Planar_map_2, Planar_map_with_intersections_2, and Arrangement_2 + types was established to include only the necessary requirements at + each level. It was determined that for the aggregate insertion- + operation based on a sweep-line algorithm only a subset of the + requirements is needed. Preconditions were added where appropriate + to tighten the requirements further. + +

      + The following functions have been renamed: +

        +
      • point_is_same() renamed to point_equal() +
      • curve_is_same() renamed to curve_equal() +
      • curve_is_in_x_range() renamed to point_in_x_range() +
      • curve_compare_at_x() renamed to curves_compare_y_at_x() + Furthermore, a precondition has been added that the reference + point is in the x-range of both curves. +
      • curve_compare_at_x_right() renamed to + curves_compare_y_at_x_to_right(). + Furthermore, a precondition has been added that both curves are + equal at the reference point and defined to its right. +
      • curve_compare_at_x_left() renamed to + curves_compare_y_at_x_to_left(). + Furthermore, a precondition has been added that both curves are + equal at the reference point and defined to its right. +
      • curve_get_point_status() renamed to curve_compare_y_at_x(). + Furthermore, a precondition has been added that the point is in + the x-range of the curve. Consequently, the function now returns a + Comparison_result (instead of a special enum). +
      • make_x_monotone() renamed to curve_make_x_monotone() + See more details below. +
      • curve_flip() renamed to curve_opposite() +
      + + The following functions have been removed: +
        +
      • curve_is_between_cw() +
      • point_to_left() +
      • point_to_right() +
      • is_x_monotone() +
      • point_reflect_in_x_and_y() +
      • curve_reflect_in_x_and_y() +
      • do_intersect_to_right() +
      • do_intersect_to_left() +
      + + Most functions, are required by the PlanarMapTraits_2 concept, + except for the make_x_monotone(), nearest_intersection_to_right(), + nearest_intersection_to_left(), curves_overlap() and + curve_opposite(). PlanarMapWithIntersectionsTraits_2 requires all + these functions, except curve_opposite(), needed only by the + ArrangementTraits_2 concept. +

      + Furthermore, the two functions curve_compare_at_x_left() and + nearest_intersection_to_left() can be omitted, if the two functions + point_reflect_in_x() and curve_reflect_in_x() are implemented. + Reflection can be avoided, if the two _left functions are supplied. + +

    2. The type X_curve_2 of the PlanarMapWithIntersectionsTraits_2 + concept was renamed to X_monotone_curve_2, and the distinction + between this type and the Curve_2 type was made firm. The method + is_x_monotone() of the PlanarMapWithIntersectionsTraits_2 concept + was removed. The related method curve_make_x_monotone() is now + called for each input curve of type Curve_2 when curves are inserted + into a Planar_map_with_intersections_2 to subdivide the input curve + into x-monotone sub-curves (and in case the curve is already + x-monotone, this function is responsible for casting it to an + x-monotone curve). + +
    3. New and improved traits classes: +
    4. Conic traits - Arr_conic_traits_2 + Support finite segments of ellipses, hyperbolas and parabolas, as + well as line segments. The traits require an exact real number- + type, such as leda_real or CORE::Expr. + +
    5. Segment cached traits - Arr_segment_cached_traits_2 + This class uses an improved representation for segments that helps + avoiding cascaded computations, thus achieving faster running + times. To work properly, an exact rational number-type should be + used. + +
    6. Polyline traits - Arr_polyline_traits_2 + The polyline traits class has been reimplemented to work in a more + efficient, generic manner. The new class replaces the obsolete + Arr_polyline_traits class. It is parameterized with a segment + traits class. + +
    7. Hyperbola and segment traits - Arr_hyper_segment_traits_2 + Supports line segments and segments of canonical hyperbolas. + This is the type of curves that arise when projecting segments + in three-space rotationally around a line onto a plane containing + the line. Such projections are often useful in CAD/CAM problems. + +
    8. Removed old traits class: +
        +
      • The models of the PlanarMapWithIntersectionsTraits_2 concept + below became obsolete, as the new conic traits, namely + Arr_conic_traits_2, supports the same functionality and is much + more efficient. +
          +
        • Arr_circles_real_traits +
        • Arr_segment_circle_traits +
        +
      • The segment traits class and the new polyline traits class were + reimplemented using standard CGAL-kernel calls. This essentially + eliminated the corresponding leda traits classes, namely: +
          +
        • Pm_leda_segment_traits_2 +
        • Arr_leda_segment_traits_2 +
        • Arr_leda_polyline_traits +
        + With the use of the Leda_rat_kernel new external package the same + functionality can be achieved with less overhead and more + efficiency. +
      + +
    9. Sweep Line
      +
        +
      • The Sweep_line_2 package was reimplemented. As a consequence it is much + more efficient, its traits is tighter (namely neither the two _left nor + the reflection functions are required), and its interface has changed a + bit. +
          +
        1. The following global functions have been removed: +
            +
          • sweep_to_produce_subcurves_2() +
          • sweep_to_produce_points_2() +
          • sweep_to_construct_planar_map_2() +
          + Instead, the public methods of the Sweep_line_2 class listed below + were introduced: +
            +
          • get_subcurves() - Given a container of curves, this function + returns a list of curves that are created by intersecting the + input curves. + +
          • get_intersection_points() - Given a range of curves, this function + returns a list of points that are the intersection points of the + curves. + +
          • get_intersecting_curves() - Given a range of curves, this function + returns an iterator to the beginning of a range that contains the + list of curves for each intersection point between any two curves + in the specified range. +
          +
        2. It is possible to construct a planar map with intersections (or an + arrangement) by inserting a range of curves into an empty map. This + will invoke the sweep-line process to construct the map more + efficiently. +
        +
      • New interface functions to the Planar_map_with_intersections_2 class. + The Planar_map_with_intersections_2 class maintains a planar map of + input curves that possibly intersect each other and are not necessarily + x-monotone. If an input curve, or a set of input curves, are known to + be x-monotone and pairwise disjoint, the new functions below can be + used to insert them into the map efficiently. +
      +
    +
  • Polyhedral Surface
    +
      +
    • The old design that was deprecated since CGAL 2.3 has been removed. +
    • Class Polyhedron_incremental_builder_3: +
        +
      • Renamed local enum ABSOLUTE to + ABSOLUTE_INDEXING, and RELATIVE to + RELATIVE_INDEXING to avoid conflicts with similarly + named macros of another library. +
      • Changed member functions add_vertex(), + begin_facet(), and end_facet() to return + useful handles. +
      • Added test_facet() to check facets for validity + before adding them. +
      • Added vertex( size_t i) to return Vertex_handle + for index i. +
      +
    + +
  • Halfedge Data Structure
    +
      +
    • The old design that was deprecated since CGAL 2.3 has been removed. +
    + +
+ +

Support Library

+ +
    +
  • New container class Compact_container, which (roughly) provides the + flexibility of std::list, with the memory compactness of std::vector. + +
  • Geomview_stream: added a function + gv.draw_triangles(InputIterator begin, InputIterator end) + which draws a set of triangles much more quickly than one by one. + +
  • Number types: +
      +
    • number types are now required to provide a function: + std::pair<double, double> to_interval(const NT &). +
    • number types are now required to provide mixed operators with "int". +
    • CLN support removed. +
    • faster square() for MP_Float. +
    • added Gmp_q. +
    + +
  • Qt_widget: +
      +
    • New classes: +
        +
      • Qt_help_window: provides a simple way to show some helpful + information about a demo as an HTML page. +
      • Qt_widget_history: provides basic functionality to manipulate + intervals of Qt_widget class. The current visible area of Qt_widget + is mapped to an interval. Each interval could be stored in the + Qt_widget_history object. So you can use this object to navigate in + history. It is mostly used by Qt_widget_standard_toolbar. +
      +
    • Changes: +
        +
      • Qt_widget_standard_toolbar: is derived from QToolBar class, so pay + attention to modify your code, if you used this class. Some public + methods were introduced to control the history object that the + toolbar use to navigate. +
      • the icons are now part of libCGALQt. +
      +
    • Deprecated members of Qt_widget: +
        +
      • add_to_history(), clear_history(), back(), forth(): use forward(), + back() and clear_history() of the Qt_widget_standard_toolbar instead. +
      • custom_redraw(): use redraw_on_back() and redraw_on_front() instead. +
      +
    • Optimizations: + the output operators of the following classes have been optimized: +
        +
      • CGAL::Segment_2 (now tests for intersection with the drawing area) +
      • CGAL::Triangle_2 (now tests for intersection with the drawing area) +
      • CGAL::Triangulation_2 (is optimized for faster display on zooming) +
      +
    +
+ +

Erratum in the Kernel manual

+ +
    +
  • Intersection test routines +

    The documentation of + CGAL::do_intersect + should mention, for the 3D case: +
    + Also, in three-dimensional space Type1 can be +

      +
    • either + Plane_3<Kernel> +
    • or Triangle_3<Kernel> +
    + and Type2 any of +
      +
    • Plane_3<Kernel> +
    • Line_3<Kernel> +
    • Ray_3<Kernel> +
    • Segment_3<Kernel> +
    • Triangle_3<Kernel> +
    + +

    + In the same way, for + Kernel::DoIntersect_3: +
    + for all pairs Type1 and Type2, where + the type Type1 is +

      +
    • either + Kernel::Plane_3 +
    • or Kernel::Triangle_3 +
    + + and Type2 can be any of the following: +
      +
    • Kernel::Plane_3 +
    • Kernel::Line_3 +
    • Kernel::Ray_3 +
    • Kernel::Segment_3 +
    • Kernel::Triangle_3 +
    + +

    + Philippe Guigue (INRIA Sophia-Antipolis) should be + mentioned as one of the authors. + +

+ +
+ +

Release 2.4

+
+

Release date: May 2002

+

Version 2.4 differs from version 2.3 in the platforms that are supported and +in functionality. There have also been a number of bug fixes for this release.

+ +

+Additional supported platforms: +

    +
  • Microsoft Visual C++, version 7. +
  • SunPro 5.3 (with patch 111685-05) on Solaris +
  • g++ 3.1 on Linux and Solaris +
+ +

+The following functionality has been added or changed:

+ +

Kernels

+ +
    +
  • Point_d has been removed from the 2D and 3D kernels. This type is + now available from the d-dimensional kernel only. +
+ +

Basic Library

+ +
    + +
  • 2D Polygon Partitioning
    + + Traits requirements for optimal partitioning have been changed slightly. +

    + +
  • 2D Sweep line
    + + A new package that implements a sweep-line algorithm to compute + arrangements of curves for different families of curves, which are + not necessarily line segments (e.g., it also works for circular arcs). + The resulting output can be the list of vertex points, the resulting + subcurves or a planar map. +

    + +
  • + Planar Maps and + + Arrangements + +
      +
    • New quicker insertion functions of Planar_map_2 for cases where more + precomputed information is available regarding the position of + the inserted curve in the map. + +
    • New query function for planar maps that determines whether a given + point is within a given face of the planar map. + +
    • New iterator over edges of planar maps in addition to the existing + iterator over halfedges. + +
    • New copy constructor and assignment operator for arrangements. +
    +

    + +
  • + Polyhedral Surface +
      +
    • new design introduced with release 2.3 now supported by VC7 compiler + +
    • Extended functionality of Polyhedron_incremental_builder: + absolute indexing allows one to add new surfaces to existing ones. +
    +

    + +
  • 2D Triangulation +
      +
    • There is a new triangulation data structure replacing the two + previous ones. This new data structure is coherent with the 3d + triangulation data structure and offer the advantages of both + previous ones. Backward compatibility is ensured and this change + is transparent for the user of triangulation classes. +
    • Constrained and Delaunay constrained triangulations are now able + to handle intersecting input constraints. + The behavior of constrained triangulations with repect to + intersection of input constraints can be customized using + an intersection tag. +
    • A new class Constrained_triangulation_plus offers a constrained + hierarchy on top of a constrained triangulations. This additionnal + data structure describes the subdivision of the original constraints + into edges of the triangulations. +
    +

    + + +
  • 3D Triangulation +
      +
    • Running time improved by a better and more compact management of + memory allocation + +
    • Various improvements and small functionalities added: +
        +
      • Triangulation_3<GT,Tds>::triangle() returns a triangle oriented + towards the outside of the cell c for facet (c,i) +
      • New function insert(Point, Locate_type, Cell_handle, int, int) + which avoids the location step. +
      • New function to get access to cells in conflict in a Delaunay + insertion : find_conflicts() and insert_in_hole() +
      • New function TDS::delete_cells(begin, end). +
      • New functions : degree(v), reorient(), remove_decrease_dimension(), + remove_from_simplex(). +
      + +
    • Changes of interface: +
        +
      • vertices and cells are the same for the triangulation data + structure and the geometric triangulation +
      • the triangulation data structure uses Vertex_handle (resp + Cell_handle) instead of Vertex* (resp Cell*). +
      • incident_cells() and incident_vertices() are templated by output + iterators +
      • changes in the iterators and circulators interface: +
          +
        • Iterators and circulators are convertible to handles + automatically, no need to call "->handle()" anymore. +
        • Vertex_iterator split into All_vertices_iterator and + Finite_vertices_iterator (and similar for cells...). +
        • TDS::Edge/Facet iterators now support operator->. +
        +
      +
    +

    +
  • 2D Search structures
    + Additional range search operations taking a predicate functor have been + added +
+ +

Support Library

+
    +
  • Qt_widget +
      +
    • We have added a new class for visualization of 2D CGAL objects. + It is derived from Trolltech's Qt class QWidget and privdes a + used to scale and pan. +
    • Some demos were developed for the following packages: 2D Alpha shapes, + 2D Convex Hull, Largest empty 2D rectangle, Maximum k-gon, + Minimum ellipse, Minimum 2D quadrilateral, 2D polygon partitioning + 2D regular and constrained triangulation. +
    • Tutorials are available to help users get used to Qt_widget +
    +

    + +
  • Timer
    + + Fixed Timer class (for user process time) to have no wrap-around + anymore on Posix-compliant systems. +
+ +

+The following functionality is no longer supported: +

    +
  • Planar maps of infinite curves (the so-called planar map bounding-box). +
+ +

+Bugs in the following packages have been fixed: + 3D Convex hull, 2D Polygon partition, simple polygon generator + +

+Also attempts have been made to assure compatability with the upcoming LEDA +release that introduces the leda namespace. + +

+

Known problems

+
    +
  • 2D Nef Polyhedra contains a memory leak. Memory problems are also + the likely cause of occasional run-time errors on some platforms. +
  • The d-dimensional convex hull computation produces run-time errors on + some platforms because of memory management bugs. +
  • The new Halfedge Data Structure design introduced with release 2.3 + does not work on VC6. See the release notes in the manual for more + information. +
  • The following deficiencies relate to planar maps, planar maps of + intersecting curves (pmwx), arrangements and sweep line. +
      +
    • On KCC, Borland and SunPro we guarantee neither compilation nor + correct execution for all of the packages above. +
    • On VC6 and VC7 we guarantee neither compilation nor correct + execution of the sweep line package. +
    • On CC (on Irix 6.5) the trapezoidal decomposition point location + strategy is problematic when used with planar maps, pmwx, or + arrangements (mind that this is the default for planar maps). +
    • On CC (on Irix 6.5) sweep line with polyline traits does not compile + (mind that the so-called leda polyline traits does compile). +
    • On g++ (on Irix 6.5) the segment-circle (Arr_segment_circle_traits_2) + traits does not compile for either of the above packages. +
    +
+ + +
+ + +

Release 2.3

+
+

Release date: August 2001

+ +

Version 2.3 differs from version 2.2 in the platforms that are supported and +in functionality.

+ +

+Additional supported platform: + +

    +
  • Gnu g++ 3.0 on Solaris and Linux +
+ +

+The following functionality has been added:

+ +

Kernels

+
    +
  • The 2D and 3D kernels now serve as models of the new kernel concept + described in the recent paper, "An Adaptable and Extensible Geometry + Kernel" by Susan Hert, Micheal Hoffmann, Lutz Kettner, Sylvain Pion, + and Michael Seel to be presented at + WAE 2001 (and + soon available as a technical report). This new kernel is + completely compatible with the previous design but is more flexible + in that it allows geometric predicates as well as objects to be easily + exchanged and adapted individually to users' needs. + +
  • A new kernel called Simple_homogeneous is available. It is + equivalent to Homogeneous but without reference-counted objects. + +
  • A new kernel called Filtered_kernel is available that allows + one to build kernel traits classes that use exact and efficient predicates. + +
  • There are two classes, Cartesian_converter and + Homogeneous_converter + that allows one to convert objects between different Cartesian and + homogeneous kernels, respectively. + +
  • A new d-dimensional kernel, Kernel_d is available. It provides + diverse kernel objects, predicates and constructions in d dimensions with + two representations based on the kernel families Cartesean_d and + Homogeneous_d +
+ +

Basic Library

+ Almost all packages in the basic library have been adapted to the + new kernel design to realize the flexibility this design makes possible. + In several packages, this means that the traits class requirements have + changed to conform to the function objects offered in the kernels so the + kernels themselves can be used as traits classes in many instances. + +
    +
  • + 2D Convex Hull
    + The traits requirements have changed slightly to bring them in line with + the CGAL kernels. + +
  • + 3D Convex Hull +
      +
    • The function convex_hull_3 now uses a new implementation of the + quickhull algorithm and no longer requires LEDA. +
    • A new convex_hull_incremental_3 function based on the new + d-dimensional convex hull class is available for comparison purposes. +

    + +
  • + Convex_hull_d, Delaunay_d
    + Two new application classes offering the calculation of d-dimensional + convex hulls and delaunay triangulations

    + +
  • + Polygons and Polygon Operations
    +
      +
    • The traits class requirements have been changed. +
    • The simplicity test has a completely new implementation. +
    • Properties like convexity, simplicity and area can now be cached by + polygons. You need to set a flag to select this behaviour. +
    +
    + +

    +
  • + Planar Nef Polyhedra
    + A new class (Nef_polyhedron_2) representing planar Nef polyhedra = + rectilinearly bounded points sets that are the result of binary and + topological operations starting from halfplanes. + +

    +
  • A new package offering functions to + + partition planar polygons into + convex and y-monotone pieces is available. + +

    +
  • + Planar Maps and + + Arrangements +
      +
    • A new class Planar_map_with_intersections_2<Planar_map> for + planar maps of possibly intersecting, possibly non-x-monotone, + possibly overlapping curves (like Arrangement_2 but without + the hierarchy tree). + +
    • I/O utilities for planar maps and arrangements for textual and + graphical streams. (It is possible to save and later reload built + planar maps or arrangements.) + +
    • New arrangement traits class for line segments and circular arcs + (Arr_segment_circle_traits<NT>). + +
    • New faster traits for polylines specialized for using the LEDA + rational kernel (Arr_leda_polylines_traits). The LEDA + traits for segments was also made faster. + +
    • A new point location strategy + (Pm_simple_point_location<Planar_map>). +
    +

    + +
  • + Halfedge Data Structure

    + + The halfedge data structure has been completely revised. The new design + is more in line with the STL naming scheme and it provides a safe and + coherent type system throughout the whole design (no void* pointers + anymore), which allows for better extendibility. A user can add new + incidences in the mesh easily. The new design also uses standard + allocators with a new template parameter that has a suitable default. +

    + + The old design is still available, but its use is deprecated, see the + manual of + deprecated packages for its documentation. Reported bugs in + copying the halfedge data structure (and therefore also polyhedral + surfaces) have been fixed in both designs. Copying a list-based + representation is now based on hash maps instead of std::map and is + therefore considerably faster. + +

    +
  • + Polyhedral Surface + +

    + The polyhedral surface has been rewritten to work with the new + halfedge data structure design. The user level interface of the + CGAL::Polyhedron_3 class is almost backwards compatible with the + previous class. The exceptions are the template parameter list, + everything that relies on the flexibility of the underlying + halfedge data structure, such as a self-written facet class, and + that the distinction between supported normals and supported planes + has been removed. Only planes are supported. See the manuals for + suggestions how to handle normals instead of planes. + +

    + More example programs are provided with polyhedral surfaces, + for example, one about Euler operator and one computing a subdivision + surface given a control mesh as input. + +

    + The old design is still available for backwards compatibility and to + support older compiler, such as MSVC++6.0. For the polyhedral surface, + old and new design cannot be used simultaneously (they have identical + include file names and class names). The include files select + automatically the old design for MSVC++6.0 and the new design + otherwise. This automatism can be overwritten by defining appropriate + macros before the include files. The old design is selected with the + CGAL_USE_POLYHEDRON_DESIGN_ONE macro. The new design is selected + with the CGAL_USE_POLYHEDRON_DESIGN_TWO macro. + +

    +
  • + 2D Triangulation +
      +
    • The geometric traits class requirements have been changed to conform + to the new CGAL kernels. CGAL kernel classes can be used as traits + classes for all 2D triangulations except for regular triangulations. + +
    • Additionnal functionality: +
        +
      • dual method for regular triangulations (to build a power diagram) +
      • unified names and signatures for various "find_conflicts()" + member functions in Delaunay and constrained Delaunay triangulation. +
      • As an alternative to the simple insert() member function, + insertion of points in those triangulation can be performed using the + combination of find_conflicts() and star_hole() which eventually + allows the user to keep track of deleted faces. +
      + +
    • More demos and examples +
    + +
    +
  • + 3D Triangulation +
      +
    • Major improvements +
        +
      • A new class Triangulation_hierarchy_3 that allows a + faster point location, and thus construction of the Delaunay + triangulation +
      • A new method for removing a vertex from a Delaunay + triangulation that solves all degenerate cases +
      • Running time of the usual location and insertion methods + improved +
      + +
    • A bit more functionality, such as +
        +
      • New geomview output +
      • dual methods in Delaunay triangulations to draw the Voronoi + diagram +
      +
    • More demos and examples + +
    • Changes in interface +
        +
      • Traits classes requirements have been modified +
      • The kernel can be used directly as a traits class (except for + regular triangulation) +
      • insert methods in Triangulation_data_structure have a + new interface +
      +
    +
    +
  • A new class (Alpha_shapes_3) that computes Alpha shapes of point + sets in 3D is available. + +

    +
  • The traits requirements for matrix search and + minimum quadrilaterals have been changed to bring them + in line with the CGAL kernels. +

    + +
  • Point_set_2 +
      +
    • now independent of LEDA; based on the CGAL Delaunay triangulation +
    • traits class requirements adapted to new kernel concept. +
    • function template versions of the provided query operations are + available +
    +
+ +

Support Library

+
    +
  • Number types: +
      +
    • Lazy_exact_nt<NT> is a new number type wrapper to speed + up exact number types. +
    • MP_Float is a new multiprecision floating point number + type. It can do exact additions, subtractions and multiplications + over floating point values. +
    + +
  • In_place_list has a new third template parameter + (with a suitable default) for an STL-compliant allocator. + +
  • + Unique_hash_map is a new support class. + +
  • + Union_find is a new support class. + +
  • + Geomview_stream : +
      +
    • Geomview version 1.8.1 is now required. +
    • no need to have a ~/.geomview file anymore. +
    • new output operators for triangulations. +
    • new output operators for Ray_2, Line_2, + Ray_3, Line_3, Sphere_3. +
    • various new manipulators. +
    + +
  • Window stream + In cooperation with Algorithmic Solutions, GmBH (distributors of + the LEDA library), we can now offer a visualization package + downloadable in binary form that supports visualization on a ported + version of the LEDA window lib. +
+ +
+ + +

Release 2.2

+
+

Release date: October 2000

+ +

Version 2.2 differs from version 2.1 in the platforms that are supported and +in functionality.

+ +

+Additional supported platforms: + +

    +
  • the KAI compiler (4.0) on Solaris 5.8 +
  • Borland C++ (5.5) +
+ +

+The following functionality has been added: + +

    +
  • There is a new, non-reference-counted kernel, Simple_cartesian. Because + reference counting is not used, and thus coordinates are stored within a + class, debugging is easier using this kernel. This kernel can also be + faster in some cases than the reference-counted Cartesian kernel. + +
  • New optimisation algorithms +
      +
    • Min_annulus_d - Algorithm for computing the smallest enclosing + annulus of points in arbitrary dimension +
    • Polytope_distance_d - Algorithm for computing the (squared) + distance between two convex polytopes in arbitrary dimension +
    • Width_3 - Algorithm for computing the (squared) width of points + sets in three dimensions +
    + +
  • 2D Triangulations +
      +
    • There are now two triangulation data structures available in CGAL. + The new one uses a list to store the faces and allows one to + represent two-dimensional triangulations embedded in three spaces + as well as planar triangulations. +
    • The triangulation hierarchy which allows fast location query + is now available. +
    + +
  • Inifinite objects can now be included in planar maps. + +
  • Removal as well as insertions of vertices for 3D Delaunay triangulations + is now possible. + +
  • A generator for ``random'' simple polygons is now available. + +
  • In directory demo/Robustness, programs that demonstrate typical robustness + problems in geometric computing are presented along with the solutions to + these problems that CGAL provides. +
+ +

+The following functionality has been removed: +

    +
  • The binary operations on polygons (union, intersection ...) have been + removed. Those operations were not documented in the previous release + (2.1). Arrangements can often be used as a substitute. +
+
+ + +

Release 2.1

+ +
+

Release date: January 2000

+ +

Version 2.1 differs from version 2.0 in the platforms that are supported and +in functionality.

+ +

+Supported platforms: + +

    +
  • the newest gnu compiler (2.95.2) on Sun, SGI, Linux and Windows. +
  • the Microsoft Visual C++ compiler, version 6. +
  • the mips CC compiler version 7.3 under Irix. +
+ +Support for the old g++ compiler (2.8) and for mips CC 7.2 has been dropped. + +

+The following functionality has been added: + +
    +
  • Alpha shapes and weighted alpha shapes in 2D. Alpha shapes are a + generalization of the convex hull of a point set. +
  • Arrangements in 2D. Arrangements are related to and based on planar maps. + The major difference between the two is that curves are allowed to + intersect in the case of arrangements. +
  • Extensions to triangulations in 2D. Constrained triangulations are now + dynamic: they support insertions of new constraint as well as removal of + existing constraints. There are also constrained Delaunay triangulations. +
  • Triangulations in 3D were added, both Delaunay triangulations and regular + triangulations. +
  • Min_quadrilateral optimisations have been added. These are algorithms to + compute the minimum enclosing rectangle/parallelogram (arbitrary + orientation) and the minimum enclosing strip of a convex point set. +
  • 2d Point_set is a package for 2d range search operations, Delaunay + triangulation, nearest neighbor queries. This package works only if + LEDA + is installed. +
  • Support for GeoWin visualization library. This also depends on + LEDA. +
  • Support for using the + CLN number type + together with CGAL. +
    • +
+
+ + +

Release 2.0

+
+

Release date: June 1999

+ +

The main difference from release 1.2 is the +introduction of namespaces -- namespace std for code from +the standard library and namespace CGAL for +the CGAL library. +

+ + +

Release 1.2

+
+

Release date: January 1999

+

Additions to release 1.1 include:

+ +
    +
  • topological map +
  • planar map overlay +
  • regular and constrained triangulations +
+
+ + +

Release 1.1

+
+

Release date: July 1998

+ +

Additions to release 1.0 include: +

    +
  • 3D intersections
    • +
  • kD points
    • +
  • 3D convex hull
    • +
  • kD smallest enclosing sphere
    • +
+
+ + + +

Release 1.0

+
+

Release date: April 1998

+ +

Additions to release 0.9 include: +

    +
  • Polyhedral surfaces
    • +
  • Halfedge Data Structure
    • +
  • Planar maps
    • +
+
+ + +

Release 0.9

+
+

Release date: June 1997

+

Initial (beta) release of the CGAL library. +

+ + +
+ + diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index c02bb9113d4..8eac44467f6 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -359,22 +359,22 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh) * The normal vector to each face is chosen pointing on the side of the face * where its sequence of vertices is seen counterclockwise. * -* @tparam TriangleMesh a model of `FaceListGraph` and `MutableFaceGraph` with no self-intersection. +* @tparam TriangleMesh a model of `FaceListGraph` and `MutableFaceGraph` . * @tparam NamedParameters a sequence of \ref namedparameters * * @param tm a triangulated `TriangleMesh` * @param np optional sequence of \ref namedparameters among the ones listed below * * \cgalNamedParamsBegin - * \cgalParamBegin{vertex_point_map} - * the property map with the points associated to the vertices of `tm`. - * If this parameter is omitted, an internal property map for - * `CGAL::vertex_point_t` should be available in `TriangleMesh` - * \cgalParamEnd - * \cgalParamBegin{face_index_map} - * a property map containing the index of each face of `tm`. - * \cgalParamEnd - * \cgalNamedParamsEnd +* \cgalParamBegin{vertex_point_map} +* the property map with the points associated to the vertices of `tm`. +* If this parameter is omitted, an internal property map for +* `CGAL::vertex_point_t` should be available in `TriangleMesh` +* \cgalParamEnd +* \cgalParamBegin{face_index_map} +* a property map containing the index of each face of `tm`. +* \cgalParamEnd +* \cgalNamedParamsEnd */ template void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) From 9fd5dda4fe0ee7178cd40c91f56b47f1d270e1a0 Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Fri, 20 Oct 2017 11:02:38 +0200 Subject: [PATCH 03/23] Add an action to inside out plugin for orienting connected components --- .../Polygon_mesh_processing/orientation.h | 5 ++ .../Plugins/PMP/Inside_out_plugin.cpp | 62 +++++++++++++++++-- 2 files changed, 62 insertions(+), 5 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 8eac44467f6..baa549c98eb 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -436,6 +436,11 @@ void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) } } +template +void orient_connected_components(TriangleMesh& tm) +{ + orient_connected_components(tm, parameters::all_default()); +} } // namespace Polygon_mesh_processing } // namespace CGAL #endif // CGAL_ORIENT_POLYGON_MESH_H diff --git a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp index bc4353a7a95..d935f5480dc 100644 --- a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp +++ b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp @@ -29,24 +29,39 @@ public: Messages_interface*) { scene = scene_interface; - QAction* actionInsideOut = new QAction(tr("Inside Out"), mw); + actionInsideOut = new QAction(tr("Inside Out"), mw); actionInsideOut->setProperty("subMenuName", "Polygon Mesh Processing"); connect(actionInsideOut, SIGNAL(triggered()), this, SLOT(on_actionInsideOut_triggered())); _actions << actionInsideOut; + actionOrientCC = new QAction(tr("Orient Connected Components"), mw); + + actionOrientCC->setProperty("subMenuName", "Polygon Mesh Processing"); + connect(actionOrientCC, SIGNAL(triggered()), this, SLOT(on_actionOrientCC_triggered())); + _actions << actionOrientCC; + + } - bool applicable(QAction*) const { + bool applicable(QAction* action) const { const CGAL::Three::Scene_interface::Item_id index = scene->mainSelectionIndex(); - return qobject_cast(scene->item(index)) - || qobject_cast(scene->item(index)) - || qobject_cast(scene->item(index)); + if(action == actionInsideOut) + return qobject_cast(scene->item(index)) + || qobject_cast(scene->item(index)) + || qobject_cast(scene->item(index)); + else if(action == actionOrientCC) + return qobject_cast(scene->item(index)) + || qobject_cast(scene->item(index)); + return false; } public Q_SLOTS: void on_actionInsideOut_triggered(); + void on_actionOrientCC_triggered(); private: + QAction* actionInsideOut; + QAction* actionOrientCC; QList _actions; Scene_interface *scene; }; // end Polyhedron_demo_inside_out_plugin @@ -94,4 +109,41 @@ void Polyhedron_demo_inside_out_plugin::on_actionInsideOut_triggered() } } +void Polyhedron_demo_inside_out_plugin::on_actionOrientCC_triggered() +{ + const CGAL::Three::Scene_interface::Item_id index = scene->mainSelectionIndex(); + + Scene_polyhedron_item* poly_item = + qobject_cast(scene->item(index)); + + Scene_surface_mesh_item* sm_item = + qobject_cast(scene->item(index)); + + if(poly_item || sm_item) + { + QApplication::setOverrideCursor(Qt::WaitCursor); + + if(poly_item) { + Polyhedron* pMesh = poly_item->polyhedron(); + if(pMesh){ + CGAL::Polygon_mesh_processing::orient_connected_components(*pMesh); + poly_item->invalidateOpenGLBuffers(); + } + } + else if(sm_item) { + SMesh* pMesh = sm_item->polyhedron(); + if(pMesh){ + CGAL::Polygon_mesh_processing::orient_connected_components(*pMesh); + sm_item->invalidateOpenGLBuffers(); + } + } + + // update scene + scene->itemChanged(index); + + // default cursor + QApplication::restoreOverrideCursor(); + } +} + #include "Inside_out_plugin.moc" From dbb63e155d6b84f4881a072a6662525a9e241852 Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Fri, 20 Oct 2017 11:33:50 +0200 Subject: [PATCH 04/23] Fices in the doc and the test --- .../Polygon_mesh_processing/orientation.h | 16 ++-- .../test_orient_cc.cpp | 91 +++++++++++++++++-- 2 files changed, 92 insertions(+), 15 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index baa549c98eb..2c03abcd45b 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -353,7 +353,7 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh) /** * \ingroup PMP_orientation_grp -* makes the orientation of all the connected_components of a `TriangleMesh` positive. +* makes the orientation of all the connected components of a `TriangleMesh` positive. * A closed polygon mesh is considered to have a positive orientation if the normal vectors * to all its faces point outside the domain bounded by the polygon mesh. * The normal vector to each face is chosen pointing on the side of the face @@ -379,9 +379,9 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh) template void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) { - typedef boost::graph_traits GT; - typedef typename GT::vertex_descriptor vertex_descriptor; - typedef typename GT::face_descriptor face_descriptor; + typedef boost::graph_traits Graph_traits; + typedef typename Graph_traits::vertex_descriptor vertex_descriptor; + typedef typename Graph_traits::face_descriptor face_descriptor; typedef typename GetVertexPointMap::const_type Vpm; typedef typename GetFaceIndexMap xtrm_vertices(nb_cc, GT::null_vertex()); + std::vector xtrm_vertices(nb_cc, Graph_traits::null_vertex()); BOOST_FOREACH(vertex_descriptor vd, vertices(tm)) { face_descriptor test_face = face(halfedge(vd, tm), tm); - if(test_face == GT::null_face()) - continue; + if(test_face == Graph_traits::null_face()) + test_face = face(opposite(halfedge(vd, tm), tm), tm); std::size_t cc_id = face_cc[get(fid_map,test_face )]; - if (xtrm_vertices[cc_id]==GT::null_vertex()) + if (xtrm_vertices[cc_id]==Graph_traits::null_vertex()) xtrm_vertices[cc_id]=vd; else if (get(vpm, vd).z()>get(vpm,xtrm_vertices[cc_id]).z()) diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index a07ce5c8f73..a8b5f6479af 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -5,20 +5,97 @@ #include #include -using namespace CGAL; -namespace PMP = Polygon_mesh_processing; +namespace PMP = CGAL::Polygon_mesh_processing; -typedef Exact_predicates_inexact_constructions_kernel Kernel; -typedef Surface_mesh Surface_mesh; +typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel; +typedef CGAL::Surface_mesh SMesh; +template +bool test_orientation(TriangleMesh& tm, const NamedParameters& np) +{ + typedef boost::graph_traits Graph_traits; + typedef typename Graph_traits::vertex_descriptor vertex_descriptor; + typedef typename Graph_traits::face_descriptor face_descriptor; + typedef typename CGAL::GetVertexPointMap::const_type Vpm; + typedef typename CGAL::GetFaceIndexMap::const_type Fid_map; + + if (!CGAL::is_triangle_mesh(tm)) + { + std::cerr<< "tested mesh is not triangle."< face_cc(num_faces(tm), std::size_t(-1)); + + // set the connected component id of each face + std::size_t nb_cc = PMP::connected_components(tm, + CGAL::bind_property_maps(fid_map,CGAL::make_property_map(face_cc)), + PMP::parameters::face_index_map(fid_map)); + + // extract a vertex with max z coordinate for each connected component + std::vector xtrm_vertices(nb_cc, Graph_traits::null_vertex()); + BOOST_FOREACH(vertex_descriptor vd, vertices(tm)) + { + face_descriptor test_face = face(halfedge(vd, tm), tm); + if(test_face == Graph_traits::null_face()) + test_face = face(opposite(halfedge(vd, tm), tm), tm); + std::size_t cc_id = face_cc[get(fid_map,test_face )]; + if (xtrm_vertices[cc_id]==Graph_traits::null_vertex()) + xtrm_vertices[cc_id]=vd; + else + if (get(vpm, vd).z()>get(vpm,xtrm_vertices[cc_id]).z()) + xtrm_vertices[cc_id]=vd; + } + std::vector > ccs(nb_cc); + BOOST_FOREACH(face_descriptor fd, faces(tm)) + { + ccs[face_cc[get(fid_map,fd)]].push_back(fd); + } + + //test ccs orientation + for(std::size_t id=0; id> sm; - PMP::orient_connected_components(sm, PMP::parameters::all_default()); + SMesh sm1, sm2; + input >> sm1; + sm2 = sm1; + PMP::orient_connected_components(sm1, PMP::parameters::all_default()); + if(!test_orientation(sm1, PMP::parameters::all_default())) + return 1; + typedef boost::property_map::type Ppmap; + typedef boost::property_map::type Fidmap; + Ppmap vpmap = get(CGAL::vertex_point, sm2); + Fidmap fidmap = get(CGAL::face_index, sm2); + + PMP::orient_connected_components(sm2, PMP::parameters::vertex_point_map(vpmap) + .face_index_map(fidmap)); + if(!test_orientation(sm2, PMP::parameters::vertex_point_map(vpmap) + .face_index_map(fidmap))) + return 1; + return 0; + + + return 0; } From b0cbe41a501ab76b4d0473aef940153e228ff543 Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Fri, 20 Oct 2017 11:49:08 +0200 Subject: [PATCH 05/23] Fixes in test. --- .../test/Polygon_mesh_processing/test_orient_cc.cpp | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index a8b5f6479af..bff11db864b 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -21,12 +21,6 @@ bool test_orientation(TriangleMesh& tm, const NamedParameters& np) typedef typename CGAL::GetFaceIndexMap::const_type Fid_map; - if (!CGAL::is_triangle_mesh(tm)) - { - std::cerr<< "tested mesh is not triangle."<> sm1; sm2 = sm1; - PMP::orient_connected_components(sm1, PMP::parameters::all_default()); + PMP::orient_connected_components(sm1); if(!test_orientation(sm1, PMP::parameters::all_default())) return 1; typedef boost::property_map::type Ppmap; From 4a381cdb42162611b23401dc09e74fd68523454f Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Fri, 20 Oct 2017 15:37:26 +0200 Subject: [PATCH 06/23] Avoid isolated vertices --- .../include/CGAL/Polygon_mesh_processing/orientation.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 2c03abcd45b..910d9c94698 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -382,6 +382,7 @@ void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) typedef boost::graph_traits Graph_traits; typedef typename Graph_traits::vertex_descriptor vertex_descriptor; typedef typename Graph_traits::face_descriptor face_descriptor; + typedef typename Graph_traits::halfedge_descriptor halfedge_descriptor; typedef typename GetVertexPointMap::const_type Vpm; typedef typename GetFaceIndexMap xtrm_vertices(nb_cc, Graph_traits::null_vertex()); BOOST_FOREACH(vertex_descriptor vd, vertices(tm)) { + halfedge_descriptor test_hd = halfedge(vd, tm); + if(test_hd == Graph_traits::null_halfedge()) + continue; face_descriptor test_face = face(halfedge(vd, tm), tm); if(test_face == Graph_traits::null_face()) test_face = face(opposite(halfedge(vd, tm), tm), tm); From 497f46f4d3380903b2502020bfb536017680af6c Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Fri, 20 Oct 2017 16:21:06 +0200 Subject: [PATCH 07/23] Robustify --- .../include/CGAL/Polygon_mesh_processing/orientation.h | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 910d9c94698..64e93c3e7e9 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -90,6 +90,10 @@ namespace internal{ BOOST_FOREACH(halfedge_descriptor he, halfedges_around_target(v_max, pmesh)) { CGAL_assertion(v_max == target(min_slope_he, pmesh)); + if(v_max != target(he, pmesh)) + { + std::cout<<"plouf"; + } CGAL_assertion(v_max == target(he, pmesh)); if(CGAL::SMALLER == compare_slope(get(vpmap, source(he, pmesh)), @@ -389,7 +393,7 @@ void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) NamedParameters>::const_type Fid_map; if (!is_triangle_mesh(tm)) return ; - + if (!is_valid(tm)) return ; Vpm vpm = boost::choose_param(get_param(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); @@ -416,6 +420,7 @@ void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) face_descriptor test_face = face(halfedge(vd, tm), tm); if(test_face == Graph_traits::null_face()) test_face = face(opposite(halfedge(vd, tm), tm), tm); + CGAL_assertion(test_face != Graph_traits::null_face()); std::size_t cc_id = face_cc[get(fid_map,test_face )]; if (xtrm_vertices[cc_id]==Graph_traits::null_vertex()) xtrm_vertices[cc_id]=vd; From 0f4f30b37baaac0fc3c1257a8fec79426ac7d6d4 Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Mon, 23 Oct 2017 10:11:03 +0200 Subject: [PATCH 08/23] Add a boolean to specify output orientation --- .../Polygon_mesh_processing/orientation.h | 47 ++++++++++--------- .../test_orient_cc.cpp | 42 +++++++++++------ 2 files changed, 53 insertions(+), 36 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 64e93c3e7e9..81688cb7a2f 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -90,10 +90,6 @@ namespace internal{ BOOST_FOREACH(halfedge_descriptor he, halfedges_around_target(v_max, pmesh)) { CGAL_assertion(v_max == target(min_slope_he, pmesh)); - if(v_max != target(he, pmesh)) - { - std::cout<<"plouf"; - } CGAL_assertion(v_max == target(he, pmesh)); if(CGAL::SMALLER == compare_slope(get(vpmap, source(he, pmesh)), @@ -357,16 +353,18 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh) /** * \ingroup PMP_orientation_grp -* makes the orientation of all the connected components of a `TriangleMesh` positive. -* A closed polygon mesh is considered to have a positive orientation if the normal vectors -* to all its faces point outside the domain bounded by the polygon mesh. -* The normal vector to each face is chosen pointing on the side of the face -* where its sequence of vertices is seen counterclockwise. +* makes the orientation of all the connected components of a `TriangleMesh` consistent. * * @tparam TriangleMesh a model of `FaceListGraph` and `MutableFaceGraph` . * @tparam NamedParameters a sequence of \ref namedparameters * * @param tm a triangulated `TriangleMesh` +* @param orient_outward indicates if the output mesh should be oriented positively (`true`) or negatively (`false`). +* default value is true. +* A closed polygon mesh is considered to have a positive orientation if the normal vectors +* to all its faces point outside the domain bounded by the polygon mesh. +* The normal vector to each face is chosen pointing on the side of the face +* where its sequence of vertices is seen counterclockwise. * @param np optional sequence of \ref namedparameters among the ones listed below * * \cgalNamedParamsBegin @@ -381,16 +379,16 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh) * \cgalNamedParamsEnd */ template -void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) +void orient_connected_components(TriangleMesh& tm, bool orient_outward, const NamedParameters& np) { typedef boost::graph_traits Graph_traits; typedef typename Graph_traits::vertex_descriptor vertex_descriptor; typedef typename Graph_traits::face_descriptor face_descriptor; typedef typename Graph_traits::halfedge_descriptor halfedge_descriptor; typedef typename GetVertexPointMap::const_type Vpm; + NamedParameters>::const_type Vpm; typedef typename GetFaceIndexMap::const_type Fid_map; + NamedParameters>::const_type Fid_map; if (!is_triangle_mesh(tm)) return ; if (!is_valid(tm)) return ; @@ -404,11 +402,8 @@ void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) // set the connected component id of each face std::size_t nb_cc = connected_components(tm, - bind_property_maps(fid_map,make_property_map(face_cc)), - parameters::face_index_map(fid_map)); - - if (nb_cc == 1) - return; + bind_property_maps(fid_map,make_property_map(face_cc)), + parameters::face_index_map(fid_map)); // extract a vertex with max z coordinate for each connected component std::vector xtrm_vertices(nb_cc, Graph_traits::null_vertex()); @@ -420,7 +415,7 @@ void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) face_descriptor test_face = face(halfedge(vd, tm), tm); if(test_face == Graph_traits::null_face()) test_face = face(opposite(halfedge(vd, tm), tm), tm); - CGAL_assertion(test_face != Graph_traits::null_face()); + CGAL_assertion(test_face != Graph_traits::null_face()); std::size_t cc_id = face_cc[get(fid_map,test_face )]; if (xtrm_vertices[cc_id]==Graph_traits::null_vertex()) xtrm_vertices[cc_id]=vd; @@ -437,18 +432,26 @@ void orient_connected_components(TriangleMesh& tm, const NamedParameters& np) //orient ccs outward for(std::size_t id=0; id +void orient_connected_components(TriangleMesh& tm, bool orient_outward) +{ + orient_connected_components(tm, orient_outward, parameters::all_default()); +} + template void orient_connected_components(TriangleMesh& tm) { - orient_connected_components(tm, parameters::all_default()); + orient_connected_components(tm, true, parameters::all_default()); } } // namespace Polygon_mesh_processing } // namespace CGAL diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index bff11db864b..7fc7646a451 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -11,7 +11,7 @@ typedef CGAL::Exact_predicates_inexact_constructions_kernel Kernel; typedef CGAL::Surface_mesh SMesh; template -bool test_orientation(TriangleMesh& tm, const NamedParameters& np) +bool test_orientation(TriangleMesh& tm, bool is_positive, const NamedParameters& np) { typedef boost::graph_traits Graph_traits; typedef typename Graph_traits::vertex_descriptor vertex_descriptor; @@ -57,7 +57,10 @@ bool test_orientation(TriangleMesh& tm, const NamedParameters& np) //test ccs orientation for(std::size_t id=0; id> sm1; sm2 = sm1; + sm3 = sm1; + sm4 = sm1; PMP::orient_connected_components(sm1); - if(!test_orientation(sm1, PMP::parameters::all_default())) + if(!test_orientation(sm1, true, PMP::parameters::all_default())) return 1; typedef boost::property_map::type Ppmap; typedef boost::property_map::type Fidmap; - Ppmap vpmap = get(CGAL::vertex_point, sm2); - Fidmap fidmap = get(CGAL::face_index, sm2); + Ppmap vpmap2 = get(CGAL::vertex_point, sm2); + Fidmap fidmap2 = get(CGAL::face_index, sm2); - PMP::orient_connected_components(sm2, PMP::parameters::vertex_point_map(vpmap) - .face_index_map(fidmap)); - if(!test_orientation(sm2, PMP::parameters::vertex_point_map(vpmap) - .face_index_map(fidmap))) + PMP::orient_connected_components(sm2, true, PMP::parameters::vertex_point_map(vpmap2) + .face_index_map(fidmap2)); + if(!test_orientation(sm2, true, PMP::parameters::vertex_point_map(vpmap2) + .face_index_map(fidmap2))) + return 1; + + PMP::orient_connected_components(sm3, false); + if(!test_orientation(sm3, false, PMP::parameters::all_default())) + return 1; + + Ppmap vpmap4 = get(CGAL::vertex_point, sm4); + Fidmap fidmap4 = get(CGAL::face_index, sm4); + + PMP::orient_connected_components(sm4, false, PMP::parameters::vertex_point_map(vpmap4) + .face_index_map(fidmap4)); + if(!test_orientation(sm4, false, PMP::parameters::vertex_point_map(vpmap4) + .face_index_map(fidmap4))) return 1; return 0; - - - - return 0; } From 67d06cadb6fbf7616d9727aec2b5eb8290d695de Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Wed, 25 Oct 2017 15:20:22 +0200 Subject: [PATCH 09/23] Add a function that orient a closed triangle mesh to make it bound a volume. --- Installation/changes.html | 3 +- .../Polygon_mesh_processing/orientation.h | 202 +++++++++++++++++- .../test_orient_cc.cpp | 13 ++ .../Plugins/PMP/Inside_out_plugin.cpp | 22 +- 4 files changed, 235 insertions(+), 5 deletions(-) diff --git a/Installation/changes.html b/Installation/changes.html index f6cda02f92d..56525850ce9 100644 --- a/Installation/changes.html +++ b/Installation/changes.html @@ -200,9 +200,10 @@ and src/ directories).

Polygon Mesh Processing

    -
  • Added a function for orienting connected components : +
  • Added two functions for orienting connected components :
    • CGAL::Polygon_mesh_processing::orient_connected_components()
      • +
    • CGAL::Polygon_mesh_processing::orient_volume_connected_components()
  • Added new functions for feature detection and feature-guided segmentation: diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 81688cb7a2f..2065e8eac31 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -38,7 +39,7 @@ #include #include - +#include namespace CGAL { namespace Polygon_mesh_processing { @@ -153,6 +154,8 @@ namespace internal{ CGAL_assertion(p2p1p4_2d == LEFT_TURN); return orientation_3(p2, p1, p4, p3) == NEGATIVE; } + + } // end of namespace internal /** @@ -350,6 +353,98 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh) } } } +}//end PMP +namespace internal { + +template +void recursive_orient_volume_ccs( TriangleMesh& tm, + Vpm& vpm, + Fid_map& fid_map, + const std::vector& xtrm_vertices, + boost::dynamic_bitset<>& cc_handled, + const std::vector& face_cc, + std::size_t xtrm_cc_id, + bool is_parent_outward_oriented) +{ + typedef boost::graph_traits Graph_traits; + typedef typename Graph_traits::face_descriptor face_descriptor; + typedef Side_of_triangle_mesh Side_of_tm; + std::vector cc_faces; + BOOST_FOREACH(face_descriptor fd, faces(tm)) + { + if(face_cc[get(fid_map, fd)]==xtrm_cc_id) + cc_faces.push_back(fd); + } +// first check that the orientation of the current cc is consistant with its +// parent cc containing it + bool new_is_parent_outward_oriented = Polygon_mesh_processing::internal::is_outward_oriented( + xtrm_vertices[xtrm_cc_id], tm, parameters::vertex_point_map(vpm)); + if (new_is_parent_outward_oriented==is_parent_outward_oriented) + { + Polygon_mesh_processing::reverse_face_orientations(cc_faces, tm); + new_is_parent_outward_oriented = !new_is_parent_outward_oriented; + } + cc_handled.set(xtrm_cc_id); + + std::size_t nb_cc = cc_handled.size(); + +// get all cc that are inside xtrm_cc_id + + typename Side_of_tm::AABB_tree aabb_tree(cc_faces.begin(), cc_faces.end(), + tm, vpm); + Side_of_tm side_of_cc(aabb_tree); + + std::vector cc_inside; + for(std::size_t id=0; id new_cc_handled(nb_cc,0); + new_cc_handled.set(); + new_cc_handled.reset(new_xtrm_cc_id); + cc_handled.set(new_xtrm_cc_id); + + std::size_t nb_candidates = cc_inside.size(); + for (std::size_t i=1;i + get(vpm,xtrm_vertices[new_xtrm_cc_id]).z()) new_xtrm_cc_id=candidate; + new_cc_handled.reset(candidate); + cc_handled.set(candidate); + } + + internal::recursive_orient_volume_ccs( + tm, vpm, fid_map, xtrm_vertices, new_cc_handled, face_cc, + new_xtrm_cc_id, new_is_parent_outward_oriented); + } + +// now explore remaining cc included in the same cc as xtrm_cc_id + boost::dynamic_bitset<> cc_not_handled = ~cc_handled; + std::size_t new_xtrm_cc_id = cc_not_handled.find_first(); + if (new_xtrm_cc_id == cc_not_handled.npos) return ; + + for (std::size_t candidate = cc_not_handled.find_next(new_xtrm_cc_id); + candidate < cc_not_handled.npos; + candidate = cc_not_handled.find_next(candidate)) + { + if(get(vpm,xtrm_vertices[candidate]).z() > get(vpm,xtrm_vertices[new_xtrm_cc_id]).z()) + new_xtrm_cc_id = candidate; + } + + internal::recursive_orient_volume_ccs( + tm, vpm, fid_map, xtrm_vertices, cc_handled, face_cc, + new_xtrm_cc_id, is_parent_outward_oriented); +} +}//end internal +namespace Polygon_mesh_processing { /** * \ingroup PMP_orientation_grp @@ -453,6 +548,111 @@ void orient_connected_components(TriangleMesh& tm) { orient_connected_components(tm, true, parameters::all_default()); } + + +/** \ingroup PMP_orientation_grp + * + * orients the connected components of `tm` to make it bound a volume. + * See \ref coref_def_subsec for details. + * + * @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph`. + * If `TriangleMesh` has an internal property map for `CGAL::face_index_t`, + * as a named parameter, then it must be initialized. + * @tparam NamedParameters a sequence of \ref namedparameters + * + * @param tm a closed triangulated surface mesh + * @param orient_outward decides if the outer component should be oriented outward or + * inward. + * @param np optional sequence of \ref namedparameters among the ones listed below + * + * \cgalNamedParamsBegin + * \cgalParamBegin{vertex_point_map} + * the property map with the points associated to the vertices of `tm`. + * If this parameter is omitted, an internal property map for + * `CGAL::vertex_point_t` should be available in `TriangleMesh` + * \cgalParamEnd + * \cgalParamBegin{face_index_map} + * a property map containing the index of each face of `tm`. + * \cgalParamEnd + * \cgalNamedParamsEnd + * + */ +template +void orient_volume_connected_components(TriangleMesh& tm, + const bool orient_outward, + const NamedParameters& np) +{ + typedef boost::graph_traits Graph_traits; + typedef typename Graph_traits::vertex_descriptor vertex_descriptor; + typedef typename GetVertexPointMap::const_type Vpm; + typedef typename GetFaceIndexMap::const_type Fid_map; + typedef typename Kernel_traits< + typename boost::property_traits::value_type >::Kernel Kernel; + typedef typename Kernel_traits< + typename boost::property_traits::value_type >::Kernel Kernel; + if (!is_closed(tm)) return; + if (!is_triangle_mesh(tm)) return; + + Vpm vpm = boost::choose_param(get_param(np, internal_np::vertex_point), + get_const_property_map(boost::vertex_point, tm)); + + Fid_map fid_map = boost::choose_param(get_param(np, internal_np::face_index), + get_const_property_map(boost::face_index, tm)); + + std::vector face_cc(num_faces(tm), std::size_t(-1)); + + + // set the connected component id of each face + std::size_t nb_cc = connected_components(tm, + bind_property_maps(fid_map,make_property_map(face_cc)), + parameters::face_index_map(fid_map)); + + if (nb_cc == 1) + { + if( orient_outward != is_outward_oriented(tm)) + reverse_face_orientations(faces(tm), tm); + return ; + } + + + boost::dynamic_bitset<> cc_handled(nb_cc, 0); + + // extract a vertex with max z coordinate for each connected component + std::vector xtrm_vertices(nb_cc, Graph_traits::null_vertex()); + BOOST_FOREACH(vertex_descriptor vd, vertices(tm)) + { + std::size_t cc_id = face_cc[get(fid_map, face(halfedge(vd, tm), tm))]; + if (xtrm_vertices[cc_id]==Graph_traits::null_vertex()) + xtrm_vertices[cc_id]=vd; + else + if (get(vpm, vd).z()>get(vpm,xtrm_vertices[cc_id]).z()) + xtrm_vertices[cc_id]=vd; + } + + //extract a vertex with max z amongst all components + std::size_t xtrm_cc_id=0; + for(std::size_t id=1; idget(vpm,xtrm_vertices[xtrm_cc_id]).z()) + xtrm_cc_id=id; + + bool is_parent_outward_oriented = + ! orient_outward; + + CGAL::internal::recursive_orient_volume_ccs(tm, vpm, fid_map, + xtrm_vertices, + cc_handled, + face_cc, + xtrm_cc_id, + is_parent_outward_oriented); +} + +template +void orient_volume_connected_components(TriangleMesh& tm, const bool orient_outward) +{ + orient_volume_connected_components(tm, orient_outward, parameters::all_default()); +} } // namespace Polygon_mesh_processing } // namespace CGAL #endif // CGAL_ORIENT_POLYGON_MESH_H diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index 7fc7646a451..b29080419b8 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include @@ -69,6 +70,7 @@ bool test_orientation(TriangleMesh& tm, bool is_positive, const NamedParameters& return true; } + int main() { @@ -105,5 +107,16 @@ int main() if(!test_orientation(sm4, false, PMP::parameters::vertex_point_map(vpmap4) .face_index_map(fidmap4))) return 1; + + + SMesh volume; + std::ifstream input2("data/Volume_nested_spheres.off"); + assert(input); + input2 >> volume; + + PMP::orient_volume_connected_components(volume, true); + if( !PMP::does_bound_a_volume(volume)) + return 1; + return 0; } diff --git a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp index d935f5480dc..f4c6a316a85 100644 --- a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp +++ b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include "Scene_polyhedron_item.h" #include "Scene_polygon_soup_item.h" #include "Scene_surface_mesh_item.h" @@ -29,6 +30,7 @@ public: Messages_interface*) { scene = scene_interface; + this->mw = mw; actionInsideOut = new QAction(tr("Inside Out"), mw); actionInsideOut->setProperty("subMenuName", "Polygon Mesh Processing"); @@ -64,6 +66,7 @@ private: QAction* actionOrientCC; QList _actions; Scene_interface *scene; + QMainWindow* mw; }; // end Polyhedron_demo_inside_out_plugin void Polyhedron_demo_inside_out_plugin::on_actionInsideOut_triggered() @@ -121,19 +124,32 @@ void Polyhedron_demo_inside_out_plugin::on_actionOrientCC_triggered() if(poly_item || sm_item) { - QApplication::setOverrideCursor(Qt::WaitCursor); + QStringList items; + items << tr("Outward") << tr("Inward"); + bool ok; + QString item = QInputDialog::getItem(mw, tr("QInputDialog::getItem()"), + tr("The connected components should be oriented:"), items, 0, false, &ok); + if (!ok ) + return; + QApplication::setOverrideCursor(Qt::WaitCursor); if(poly_item) { Polyhedron* pMesh = poly_item->polyhedron(); if(pMesh){ - CGAL::Polygon_mesh_processing::orient_connected_components(*pMesh); + if(is_closed(*pMesh)) + CGAL::Polygon_mesh_processing::orient_volume_connected_components(*pMesh, item==items.first()); + else + CGAL::Polygon_mesh_processing::orient_connected_components(*pMesh, item==items.first()); poly_item->invalidateOpenGLBuffers(); } } else if(sm_item) { SMesh* pMesh = sm_item->polyhedron(); if(pMesh){ - CGAL::Polygon_mesh_processing::orient_connected_components(*pMesh); + if(is_closed(*pMesh)) + CGAL::Polygon_mesh_processing::orient_volume_connected_components(*pMesh, item==items.first()); + else + CGAL::Polygon_mesh_processing::orient_connected_components(*pMesh, item==items.first()); sm_item->invalidateOpenGLBuffers(); } } From 6c42ce6958dfbce2d2ce61b17272edb64290088b Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Wed, 15 Nov 2017 12:31:49 +0100 Subject: [PATCH 10/23] Doc review --- Installation/changes.html | 4 +-- .../Polygon_mesh_processing/corefinement.h | 1 + .../Polygon_mesh_processing/orientation.h | 32 +++++++++---------- .../test_orient_cc.cpp | 10 +++--- .../Plugins/PMP/Inside_out_plugin.cpp | 8 ++--- 5 files changed, 28 insertions(+), 27 deletions(-) diff --git a/Installation/changes.html b/Installation/changes.html index 56525850ce9..ca291b34d21 100644 --- a/Installation/changes.html +++ b/Installation/changes.html @@ -202,8 +202,8 @@ and src/ directories).
    • Added two functions for orienting connected components :
        -
      • CGAL::Polygon_mesh_processing::orient_connected_components()
        • -
      • CGAL::Polygon_mesh_processing::orient_volume_connected_components()
        • +
      • CGAL::Polygon_mesh_processing::orient()
        • +
      • CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()
    • Added new functions for feature detection and feature-guided segmentation: diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h index 59f82da165a..286c74eb923 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/corefinement.h @@ -149,6 +149,7 @@ bool recursive_does_bound_a_volume(const TriangleMesh& tm, * \cgalParamEnd * \cgalNamedParamsEnd * + * \see `CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()` */ template bool does_bound_a_volume(const TriangleMesh& tm, const NamedParameters& np) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 2065e8eac31..bcc02ce5ae6 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -454,7 +454,7 @@ namespace Polygon_mesh_processing { * @tparam NamedParameters a sequence of \ref namedparameters * * @param tm a triangulated `TriangleMesh` -* @param orient_outward indicates if the output mesh should be oriented positively (`true`) or negatively (`false`). +* @param orient_positively indicates if the output mesh should be oriented positively (`true`) or negatively (`false`). * default value is true. * A closed polygon mesh is considered to have a positive orientation if the normal vectors * to all its faces point outside the domain bounded by the polygon mesh. @@ -474,7 +474,7 @@ namespace Polygon_mesh_processing { * \cgalNamedParamsEnd */ template -void orient_connected_components(TriangleMesh& tm, bool orient_outward, const NamedParameters& np) +void orient(TriangleMesh& tm, bool orient_positively, const NamedParameters& np) { typedef boost::graph_traits Graph_traits; typedef typename Graph_traits::vertex_descriptor vertex_descriptor; @@ -527,10 +527,8 @@ void orient_connected_components(TriangleMesh& tm, bool orient_outward, const Na //orient ccs outward for(std::size_t id=0; id -void orient_connected_components(TriangleMesh& tm, bool orient_outward) +void orient(TriangleMesh& tm, bool orient_positively) { - orient_connected_components(tm, orient_outward, parameters::all_default()); + orient(tm, orient_positively, parameters::all_default()); } template -void orient_connected_components(TriangleMesh& tm) +void orient(TriangleMesh& tm) { - orient_connected_components(tm, true, parameters::all_default()); + orient(tm, true, parameters::all_default()); } /** \ingroup PMP_orientation_grp * * orients the connected components of `tm` to make it bound a volume. - * See \ref coref_def_subsec for details. + * See \ref coref_def_subsec for a precise definition. * * @tparam TriangleMesh a model of `MutableFaceGraph`, `HalfedgeListGraph` and `FaceListGraph`. * If `TriangleMesh` has an internal property map for `CGAL::face_index_t`, @@ -561,8 +559,9 @@ void orient_connected_components(TriangleMesh& tm) * @tparam NamedParameters a sequence of \ref namedparameters * * @param tm a closed triangulated surface mesh - * @param orient_outward decides if the outer component should be oriented outward or - * inward. + * @param orient_outward decides if the outer components should be oriented outward or + * inward. In this specific case, inwards means that the infinity will be considered + * as inside the volume bounded by `tm`. * @param np optional sequence of \ref namedparameters among the ones listed below * * \cgalNamedParamsBegin @@ -576,9 +575,10 @@ void orient_connected_components(TriangleMesh& tm) * \cgalParamEnd * \cgalNamedParamsEnd * + * \see `CGAL::Polygon_mesh_processing::does_bound_a_volume()` */ template -void orient_volume_connected_components(TriangleMesh& tm, +void orient_to_bound_a_volume(TriangleMesh& tm, const bool orient_outward, const NamedParameters& np) { @@ -649,9 +649,9 @@ void orient_volume_connected_components(TriangleMesh& tm, } template -void orient_volume_connected_components(TriangleMesh& tm, const bool orient_outward) +void orient_to_bound_a_volume(TriangleMesh& tm, const bool orient_outward) { - orient_volume_connected_components(tm, orient_outward, parameters::all_default()); + orient_to_bound_a_volume(tm, orient_outward, parameters::all_default()); } } // namespace Polygon_mesh_processing } // namespace CGAL diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index b29080419b8..1e15f42f042 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -81,7 +81,7 @@ int main() sm2 = sm1; sm3 = sm1; sm4 = sm1; - PMP::orient_connected_components(sm1); + PMP::orient(sm1); if(!test_orientation(sm1, true, PMP::parameters::all_default())) return 1; typedef boost::property_map::type Ppmap; @@ -89,20 +89,20 @@ int main() Ppmap vpmap2 = get(CGAL::vertex_point, sm2); Fidmap fidmap2 = get(CGAL::face_index, sm2); - PMP::orient_connected_components(sm2, true, PMP::parameters::vertex_point_map(vpmap2) + PMP::orient(sm2, true, PMP::parameters::vertex_point_map(vpmap2) .face_index_map(fidmap2)); if(!test_orientation(sm2, true, PMP::parameters::vertex_point_map(vpmap2) .face_index_map(fidmap2))) return 1; - PMP::orient_connected_components(sm3, false); + PMP::orient(sm3, false); if(!test_orientation(sm3, false, PMP::parameters::all_default())) return 1; Ppmap vpmap4 = get(CGAL::vertex_point, sm4); Fidmap fidmap4 = get(CGAL::face_index, sm4); - PMP::orient_connected_components(sm4, false, PMP::parameters::vertex_point_map(vpmap4) + PMP::orient(sm4, false, PMP::parameters::vertex_point_map(vpmap4) .face_index_map(fidmap4)); if(!test_orientation(sm4, false, PMP::parameters::vertex_point_map(vpmap4) .face_index_map(fidmap4))) @@ -114,7 +114,7 @@ int main() assert(input); input2 >> volume; - PMP::orient_volume_connected_components(volume, true); + PMP::orient_to_bound_a_volume(volume, true); if( !PMP::does_bound_a_volume(volume)) return 1; diff --git a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp index f4c6a316a85..aac56db2864 100644 --- a/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp +++ b/Polyhedron/demo/Polyhedron/Plugins/PMP/Inside_out_plugin.cpp @@ -137,9 +137,9 @@ void Polyhedron_demo_inside_out_plugin::on_actionOrientCC_triggered() Polyhedron* pMesh = poly_item->polyhedron(); if(pMesh){ if(is_closed(*pMesh)) - CGAL::Polygon_mesh_processing::orient_volume_connected_components(*pMesh, item==items.first()); + CGAL::Polygon_mesh_processing::orient_to_bound_a_volume(*pMesh, item==items.first()); else - CGAL::Polygon_mesh_processing::orient_connected_components(*pMesh, item==items.first()); + CGAL::Polygon_mesh_processing::orient(*pMesh, item==items.first()); poly_item->invalidateOpenGLBuffers(); } } @@ -147,9 +147,9 @@ void Polyhedron_demo_inside_out_plugin::on_actionOrientCC_triggered() SMesh* pMesh = sm_item->polyhedron(); if(pMesh){ if(is_closed(*pMesh)) - CGAL::Polygon_mesh_processing::orient_volume_connected_components(*pMesh, item==items.first()); + CGAL::Polygon_mesh_processing::orient_to_bound_a_volume(*pMesh, item==items.first()); else - CGAL::Polygon_mesh_processing::orient_connected_components(*pMesh, item==items.first()); + CGAL::Polygon_mesh_processing::orient(*pMesh, item==items.first()); sm_item->invalidateOpenGLBuffers(); } } From 687e5b6c600d55494e8f5da79e5138f1997aa3ce Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Wed, 15 Nov 2017 16:46:00 +0100 Subject: [PATCH 11/23] Add requirement close for orient function --- .../CGAL/Polygon_mesh_processing/orientation.h | 3 ++- .../test/Polygon_mesh_processing/test_orient_cc.cpp | 11 ++++++----- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index bcc02ce5ae6..0eb2a055366 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -453,7 +453,7 @@ namespace Polygon_mesh_processing { * @tparam TriangleMesh a model of `FaceListGraph` and `MutableFaceGraph` . * @tparam NamedParameters a sequence of \ref namedparameters * -* @param tm a triangulated `TriangleMesh` +* @param tm a closed triangulated `TriangleMesh` * @param orient_positively indicates if the output mesh should be oriented positively (`true`) or negatively (`false`). * default value is true. * A closed polygon mesh is considered to have a positive orientation if the normal vectors @@ -487,6 +487,7 @@ void orient(TriangleMesh& tm, bool orient_positively, const NamedParameters& np) if (!is_triangle_mesh(tm)) return ; if (!is_valid(tm)) return ; + if (!is_closed(tm)) return; Vpm vpm = boost::choose_param(get_param(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index 1e15f42f042..3cb4bdf0858 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -74,13 +74,18 @@ bool test_orientation(TriangleMesh& tm, bool is_positive, const NamedParameters& int main() { +<<<<<<< HEAD std::ifstream input("data-coref/nested_cubes_invalid_volume.off"); +======= + std::ifstream input("data/Volume_nested_spheres.off"); +>>>>>>> 5bf8e4d86b... Add requirement close for orient function assert(input); - SMesh sm1, sm2, sm3, sm4; + SMesh sm1, sm2, sm3, sm4, volume; input >> sm1; sm2 = sm1; sm3 = sm1; sm4 = sm1; + volume = sm1; PMP::orient(sm1); if(!test_orientation(sm1, true, PMP::parameters::all_default())) return 1; @@ -109,10 +114,6 @@ int main() return 1; - SMesh volume; - std::ifstream input2("data/Volume_nested_spheres.off"); - assert(input); - input2 >> volume; PMP::orient_to_bound_a_volume(volume, true); if( !PMP::does_bound_a_volume(volume)) From e0eca970d243dc8ffa1992f2f6091ec6c8f7ec92 Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Fri, 17 Nov 2017 14:04:09 +0100 Subject: [PATCH 12/23] Remove changes.html --- Installation/changes.html | 5556 ------------------------------------- Installation/changes.md | 4 + 2 files changed, 4 insertions(+), 5556 deletions(-) delete mode 100644 Installation/changes.html diff --git a/Installation/changes.html b/Installation/changes.html deleted file mode 100644 index ca291b34d21..00000000000 --- a/Installation/changes.html +++ /dev/null @@ -1,5556 +0,0 @@ - - - - - - - - - - CGAL - Release History - - - - - - - - - - - - - - -
      -

      Release History

      - -
      - - - -
      - - - -
      4.12  (April 2018) -
      4.11  (September 2017) -
      4.10  (May 2017) -
      4.9  (September 2016) -
      4.8  (April 2016) -
      4.7  (October 2015) -
      4.6.2  (August 2015) -
      4.6.1  (June 2015) -
      4.6  (April 2015) -
      4.5.2  (February 2015) -
      4.5.1  (December 2014) -
      4.5  (October 2014) -
      4.4  (April 2014) -
      4.3.1  (November 2013) -
      4.3  (October 2013) -
      4.2  (March 2013) -
      4.1  (September 2012) -
      4.0.2  (July 2012) -
      4.0.1  (July 2012) -
      4.0  (March 2012) -
      3.9  (September 2011) -
      3.8  (April 2011) -
      3.7  (October 2010) -
      3.6.1  (June 2010) -
      3.6  (March 2010) -
      3.5.1  (December 2009) -
      3.5  (October 2009) -
      3.4  (January 2009) -
      3.3.1 (August 2007) -
      3.3 (May 2007) -
      3.2.1 (July 2006) -
      3.2 (May 2006) -
      3.1 (December 2004) -
      3.0.1 (February 2004) -
      3.0 (October 2003) -
      2.4 (May 2002) -
      2.3 (August 2001) -
      2.2 (October 2000) -
      2.1 (January 2000) -
      2.0 (June 1999) -
      1.2 (January 1999) -
      1.1 (July 1998) -
      1.0 (April 1998) -
      0.9 (June 1997) -
      - -      		 - - -
      -Number of lines of code of CGAL
      -(using David A. Wheeler's -'SLOCCount', restricted to the include/CGAL/ -and src/ directories). -
      Releases size graph -
      -      		 -
      - -
      -

      Release 4.12

      -
      -

      Release date: April 2018

      - -

      2D Movable Separability of Sets

      -
        -

      • A new packaged 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.<\p> - -

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

      2D Alpha Shapes

      -
        -
      • It is now possible to use CGAL::Periodic_2_triangulation_2 - as underlying triangulation for Alpha_shape_2.
        • -
      - -

      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 - class Triangulation_hierarchy_vertex_base_2, which is identical.
        • -
      • Breaking change: - The functions circumcenter(), side_of_oriented_circle(), - and is_extensible_in_1_sheet_h[12]() are related to - Delaunay triangulations and have been moved from Periodic_2_triangulation_2 - to Periodic_2_Delaunay_triangulation_2.
        • -
      - - -

      3D Surface Mesh Generation

      -
        -
      • - Add the function facets_in_complex_2_to_triangle_mesh() - that exports Surface_mesh_complex_2_in_triangulation_3 - facets into a MutableFaceGraph. -
        • -
      -

      3D Mesh Generation

      -
        -
      • - Add the function facets_in_complex_3_to_triangle_mesh() - that exports Mesh_complex_3_in_triangulation_3 - facets into a MutableFaceGraph. -
        • -
      - - -

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

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

      Point Set Processing

      -
        -
      • Breaking change: the API - of CGAL::structure_point_set() is generalized to accept - other types of input than the RANSAC output.
        • -
      - - - - - - - -

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

      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 - concept Kernel but must now be marked with - the explicit 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 - and Alpha_shape_mesher.
        • -
      • Alternative smoothing and meshing methods are - provided: Jet_smoother - and Advancing_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 concept Kernel are models of - this new concept. -
        • -
      • - The concept AlphaShapeTraits_2 now provides requirements - on the traits class for 2D basic alpha shapes, and - refines DelaunayTriangulationTraits_2. -
        • -
      -

      Interpolation

      -
        -
      • Breaking change: The - concept GradientFittingTraits now additionally requests a - weighted point type Weighted_point_d and a - functor Construct_point_d. The model - CGAL::Interpolation_gradient_fitting_traits_2 has been - appropriately modified to still be a model of the - concept GradientFittingTraits. -
        • -
      -

      2D and 3D Triangulations

      -
        -
      • Breaking change: Added a new functor - requirement, Construct_point_2, to the concepts - TriangulationTraits_2 - and RegularTriangulationTraits_2 and a new functor - requirement, Construct_point_3, to the concepts - TriangulationTraits_3 - and RegularTriangulationTraits_3. All models of the - concept Kernel already provide these functors. -
        • -
      • Breaking change: Introduced the - concepts RegularTriangulationVertexBase_2 and - RegularTriangulationVertexBase_3. These concepts - describe the requirements on classes meant to represent a vertex of a - regular triangulation. Concepts that previously - refined TriangulationVertexBase_2 or - TriangulationVertexBase_3 but described in fact a vertex - class used in a regular triangulation, such as the - concept MeshVertexBase_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 to - Traits::Point_[23] for basic and Delaunay triangulations - or to - Traits::Weighted_point_[23] for regular - triangulations. Consequently: -
          -
        • - The concept RegularTriangulationVertexBase_2 now - requests a Point type (equal - to Traits::Weighted_point_2) -
          • -
        • - The concept RegularTriangulationCellBase_3 now - requests a Point type instead of - a Weighted_point type (but still equal - to Traits::Weighted_point_3) -
          • -
        • - The concept DelaunayTriangulationCellBase_3 now - requests a Point type instead of - a Point_3 type (but still equal - to Traits::Point_3). -
          • -
        -
        • -
      • - Introduced a new concept, - RegularTriangulationCellBaseWithWeightedCircumcenter_3, - which describes the requirements on a cell of a regular triangulation - that caches its circumcenter. The existing class - Regular_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 - functors Construct_weighted_circumcenter_3, - Compute_squared_radius_3, and - Compute_squared_radius_smallest_orthogonal_sphere_3. - This class can be used as traits class in the the Mesh_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 - inherits Periodic_3_triangulation_traits_3. -
        • -
      • Breaking change: Some geometric access functions - in Periodic_3_triangulation_3 were renamed. The - introduction of Periodic_3_regular_triangulation_3 - required to distinguish between functions such - as segment() 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 containing construct 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 class - Regular_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 - from Triangulation::Point to - TriangulationTraits::Point_3 to reflect that it is a - weightless point. -
        • -
      • Breaking change: The - function invalidate_circumcenter() of the - concept MeshCellBase_3 is renamed to - invalidate_weighted_circumcenter_cache() and moved to - the new concept - RegularTriangulationCellBaseWithWeightedCircumcenter_3, - which the concept MeshCellBase_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 - concepts BidirectionalGraph and - EdgeAndVertexListGraph and of the - concept MutableFaceGraph. 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. The Seam_mesh is a - graph adaptor which allows to create virtual borders when marking - edges as seam edges. -
        • -
      • Add the functions read_off() - and write_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 - requires Boost.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 - concept MutableFaceGraph. Models provided by CGAL have - been updated. -
        • -
      - -

      2D and 3D Linear Geometry Kernel

      -
        -
      • Breaking change: The function compare_slopes() was renamed compare_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 function compare_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 - concept MutableFaceGraph
        • -
      • The function convex_hull_3_to_polyhedron_3() is - deprecated and convex_hull_3_to_face_graph.h should be - used instead.
        • -
      • The class Convex_hull_traits_3 now documents a nested - type Polygon_mesh instead - of Polyhedron_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 - renamed Linear_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 concept Kernel/
        • -
      • The class Regular_triangulation_2 can take a kernel as - template argument, that is one no longer has to - use Regular_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 concept Kernel/
        • -
      • The class Regular_triangulation_3 can take a kernel as - template argument, that is one no longer has to - use Regular_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 of FaceGraph. -
        • -
      - -

      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 renamed CGAL::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 a Nef_polyhedron_3 to any model of - the MutableFaceGraph 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 - and CGAL::Random_points_in_triangles_2).
          • -
        • on a 3D segment - (CGAL::Random_points_on_segment_3).
          • -
        -
        • -
      -
      - -

      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 - the CombinatorialMap 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() - and CGAL::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() - and AABB_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 - a FaceGraph and a creation - function CGAL::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 - keyword thread_local and the C+11 - class std::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 and - GeneralPolygonSetDcelFace for more details. If you use a - different simplex types, inheriting your simplices from - CGAL::Gps_face_base - and CGAL::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 - function bbox().
        • -
      -

      Advancing Front Surface Reconstruction

      -
        -
      • Optional template functor Filter is replaced by - another optional template functor Priority. 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 - old Filter API will not compile anymore as it must be - replaced with the Priority 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 - functions compute_average_spacing(), - edge_aware_upsample_point_set(), - jet_estimate_normals(), - jet_smooth_point_set(), - and pca_estimate_normals(). To update your code simply - add as first template parameter CGAL::Sequential_tag - or CGAL::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() - and CGAL::write_ply_points_and_normals().
        • -
      -

      Surface Mesh Parameterization

      -
        -
      • LSCM_parameterizer_3 now uses by default Eigen - instead of OpenNL as a model - of SparseLinearAlgebraTraits_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 - functions CGAL::linear_least_squares_fitting_2() - and CGAL::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 of DiagonalizeTraits). 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() - and CGAL::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 file Qt5Config.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 concept FaceGraph. -
        • -
      - -

      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 and - ArrangementConstructXMonotoneCurveTraits_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 - the ArrangementConstructXMonotoneTraits_2 concept - among the other when Arr_polyline_traits_2 is - instantiated. -
          • -
        -
        • -
      - -

      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 - pergorms the implementation of the exsisting (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 to - Periodic_3_Delaunay_triangulation_traits_3. -
        • -
      • Rename the concept Periodic_3TriangulationTraits_3 to - Periodic_3DelaunayTriangulationTraits_3. -
        • -
      • Create Periodic_3_triangulation_traits_3 and the - concept Periodic_3TriangulationTraits_3. -
        • -
      - -

      2D Conforming Triangulations and Meshes

      -
        -
      • - Add an optimization method CGAL::lloyd_optimize_mesh_2() - that implements the Lloyd (or Centroidal Voronoi Tesselation) - optimization algorithm in a Constrained Delaunay Triangulation. For - optimization, the triangulation data structure on which the mesher - relies needs its VertexBase template parameter to be a - model of the new concept DelaunayMeshVertexBase_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 - function CGAL::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 by CGAL::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 and - CGAL::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 - and CGAL::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 and - halfspace_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 kernel - Exact_predicates_inexact_constructions_kernel.
        • -
      • The function CGAL::convex_hull_incremental_3 is deprecated and - the function convex_hull_3 should be used instead.
        • -
      - - -

      Combinatorial Maps and Linear Cell Complex

      -
        -
      • Added correct_invalid_attributes, - set_automatic_attributes_management and - are_attributes_automatically_managed methods in - CombinatorialMap 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 replaces pair<Vertex_handle,Vertex_handle> as - identifier of a constraint. -
      - - -

      3D Mesh Generation

      -
        -
      • Add member functions output_boundary_to_off and - output_facets_in_complex_to_off - in the class CGAL::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 and - AABB_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 - compile boost::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 for min_distance_to_rectangle and - max_distance_to_rectangle with an additional reference - parameter std::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 - and kd_tree_internal_node from kd_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 to CGAL::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 - class boost::graph_traits.
          • -
        • Deprecation of halfedge_graph_traits.
          • -
        • A model of HalfedgeGraph is considered as an - undirected graph. Thus any call to edges() should be - replaced by halfedges() and num_edges() - now returns the number of (undirected) edges. -
        • Breaking change: is_border_edge - and is_border_halfedge properties are removed. The - free functions is_border() - and is_border_edge() should be used instead.
          • -
        • Renaming of HalfedgeGraph specific free - functions.
          • -
        -
        • -
      • 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 - for OpenMesh::PolyMesh_ArrayKernelT as proof of - concept. A OpenMesh::PolyMesh_ArrayKernelT becomes a - model of the aforementioned concepts when including - CGAL/boost/graph/graph_traits_PolyMesh_ArrayKernelT.h.
        • -
      - - -

      dD Geometry Kernel

      -
        -
      • A new model Epick_d of the Kernel_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 - official Kd_tree from Spatial_searching - package; results in a small performance gain. Removed the - private kd_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 when cell->circumcenter() - or rt.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 - an Iso_cuboid_3.
        • -
      • Add a new labeling function wrapper for meshing multi-domain.
        • -
      • The meshing functionality in the Qt demos - in demo/Polyhedron/ and demo/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 parameter - edge_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) and size_t - capacity() to class Kd_tree to allocate memory - to store size 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 - the CombinatorialMap concept. This implies to move the - following methods of Dart concept - into CombinatorialMap - concept: is_free, highest_nonfree_dimension, - opposite and other_extremity. We also - transform the static methods vertex_attribute - and point of Linear_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 - and number_of_cells in - Mesh_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 function - edge_collapse
        • -
      - -

      dD Spatial Searching

      -
        -
      • Fix a documentation bug: The property map passed as template - parameter to the classes - Search_traits_adapter and Distance_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 use boost::variant instead - of CGAL::Object. The result_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 to CGAL::Object. However, it is - recommended to upgrade your code. The previous behavior can be - restored by defining the - macro CGAL_INTERSECTION_VERSION to 1. -
        • -
      -

      2D Arrangements

      -
        -
      • The type of the result of point location queries changed to - boost::variant (from CGAL::Object). - For convenience, the previous behavior can be restored by defining - the macro CGAL_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 class - Intersection_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, - the key_type has been changed to be - the value_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 - macro CGAL_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 - a Bbox_2 and an Iso_cuboid_3 from - a Bbox_3.
        • -
      • The implementation of CGAL::Object has been updated - and now uses boost::shared_ptr - and boost::any. This implementation is faster. -
        • -
      • Add to Bbox_2 and Bbox_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 - or Exact_predicates_exact_constructions_kernel as - kernel.
        • -
      - -

      2D Triangulations

      -
        -
      • Extend the concept TriangulationDataStructure_2 to - require a more general copy_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 general copy_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 - and insert_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 - function insert(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 - parameter do_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 and - Mesh_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 class - Intersection_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 class AABB_polyhedron_segment_primitive - (which is now deprecated). The new class is more general and can be - used with any model of HalfedgeGraph.
        • -
      • Introduce the class AABB_face_graph_triangle_primitive - which replaces the - class AABB_polyhedron_triangle_primitive (which is now - deprecated).
        • -
      • Document the classes AABB_segment_primitive - and AABB_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 - a AABB_tree. With this you can, for example have a - primitive wrapping an integer which refers to the position of a - geometric object in a std::vector. Only one reference - to this vector will be stored in the traits of the tree. The - concept AABBTraits, its model AABB_traits - and the class AABB_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 - and Dispatch_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 line -
        -  link_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 - and Constrained_Delaunay_triangulation_2. -
      • Add a constructor for Regular_triangulation_2 - and Delaunay_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 - and AABBGeomTraits 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 the result_of - mechanism. When all compilers supported by CGAL will have a Standard - compliant implemention of the C++11 decltype feature, it - will become an alias to - std::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 renamed cpp11. 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 defining CGAL_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. Use Random_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 defining CGAL_HAS_NO_THREADS.
        • -
      • Bug-fix in Orthogonal_incremental_neighbor_search and Incremental_neighbor_search classes. Several calls to begin() - now allow to make several nearest neighbor search queries independently.
        • -
      - -

      STL Extension

      -
        -
      • CGAL::copy_n is now deprecated for CGAL::cpp0x::copy_n which uses std::copy_n, if available on the platform.
        • -
      • CGAL::successor and CGAL::predecessor are now deprecated for CGAL::cpp0x::next and CGAL::cpp0x::prev. These functions - use the standard versions if available on the platform. Otherwise, boost::next and boost::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 defining CGAL_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 class Sqrt_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 the Root_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.
        • -
      - -

      3D Convex Hull (major performance improvement)

      -
        -
      • The quickhull implementation of CGAL (CGAL::convex_hull_3) - has been worked out to provide very better performances.
        • -
      • The function CGAL::convex_hull_3 no longer computes the plane - equations of the facets of the output polyhedron. However an example is - provided to show how to compute them easily.
        • -
      • A global function convex_hull_3_to_polyhedron_3 is now provided to extract - the convex hull of a 3D points set from a triangulation of these points.
        • -
      - -

      dD Spatial Searching (major new feature added)

      -
        -
      • A traits-class and distance adapter that together with a point property map, - allow to make nearest neighbor queries on keys instead of points have been added.
        • -
      • Few bug fixes in the documentation have revealed some inconsistencies - that have been corrected. Two traits class concept are now documented (RangeSearchTraits - and SearchTraits). Most other changes concerns only classes documented as advanced. - One issue that user can encounter is due to an additional requirement on the nested - class Construct_cartesian_const_iterator_d defined in the concept SearchTraits that must - provide a nested type result_type.
        • -
      - -

      Spatial Sorting (major new feature added)

      -
        -
      • General dimension is now supported.
        • -
      • Hilbert sorting admits now two policies: splitting at - median or at middle (see user manual).
        • -
      • Using a property map, sorting on keys instead of points is now easier
        • -
      - -

      dD Kernel

      -
        -
      • The d-dimensional kernel concept and models have been modified - to additionally provide two new functors Less_coordinate_d and Point_dimension_d.
        • -
      - -

      2D Arrangements

      -
        -
      • A new geometry-traits class that handles rational arcs, namely - Arr_rational_function_traits_2, has been introduced. - It replaced an old traits class, which handled the same family of - curves, but it was less efficient. The new traits exploits CGAL - algebraic kernels and polynomials, which were not available at - the time the old traits class was developed.
        • -
      • A new geometry traits concept called - ArrangementOpenBoundaryTraits_2 has been introduced. - A model of this concept supports curves that approach the open - boundary of an iso-rectangular area called parameter space, which can - be unbounded or bounded. The general code of the package, however, - supports only the unbounded parameter space. We intend to enhance the - general code to support also bounded parameter spaces in a future - release.
        • -
      • The deprecated member function is_at_infinity() of - Arrangement_2::Vertex has been removed. It has been previously - replaced new function is_at_open_boundary(). - -
      • The tags in the geometry traits that indicate the type of boundary of - the embedding surface were replaced by the following new tags: -
        -         Left_side_category
-         Bottom_side_category
-         Top_side_category
-         Right_side_category
-
        - It is still possible not to indicate the tags at all. Default values are assumed. This however will - produce warning messages, and should be avoided.
        • -
      -
      - - -

      Release 3.8

      -
      -

      Release date: April 2011

      - -

      -CGAL 3.8 offers the following improvements and new functionality :

      - -

      General

      -
        -
      • Boost version 1.39 at least is now required.
        • -
      • Initial support for the LLVM Clang compiler (prereleases of version 2.9).
        • -
      • Full support for the options -strict-ansi of the Intel Compiler 11, - and -ansi of the GNU g++ compiler.
        • -
      • Adding a concept of ranges. In the following releases, it will be the - way to provide a set of objects (vs. a couple of iterators).
        • -
      • Fix a memory leak in CORE polynomials.
        • -
      • Various fixes in the manual.
        • -
      - -

      3D Mesh Generation (major new feature added)

      -
        -
      • Adding the possibility to handle sharp features: the 3D Mesh - generation package now offers the possibility to get in the final mesh an - accurate representation of 1-dimensional sharp features present in the - description of the input domain. -
      - -

      2D Triangulations (major new feature added)

      -
        -
      • Add a way to efficiently insert a range of points with information - into a 2D Delaunay and regular triangulation. -
      • Add member function mirror_edge taking an edge as parameter. -
      • Fix an infinite loop in constrained triangulation. -
      - -

      3D Triangulations (major new feature added)

      -
        -
      • Add a way to efficiently insert a range of points with information into - a 3D Delaunay and regular triangulation. -
      • Add a member function to remove a cluster of points from a Delaunay or - regular triangulation. -
      • function vertices_in_conflict is renamed vertices_on_conflict_zone_boundary - for Delaunay and regular triangulation. Function vertices_inside_conflict_zone - is added to regular triangulation. -
      • Structural filtering is now internally used in locate function of Delaunay - and regular triangulation. It improves average construction time by 20%. -
      • Added demo. -
      - -

      3D Alpha Shapes (major new feature added)

      -
        -
      • The new class Fixed_alpha_shape_3 provides a robust and - faster way to compute one alpha shape (with a fixed value of alpha). -
      - - -

      AABB tree

      -
        -
      • Adding the possibility to iteratively add primitives to an existing - tree and to build it only when no further insertion is needed. -
      - -

      2D and 3D Kernel

      -
        -
      • Better handling of 2D points with elevation (3D points projected onto - trivial planes). More general traits classes (Projection_traits_xy_3, - Projection_traits_yz_3,Projection_traits_yz_3) are provided to work with - triangulations, algorithms on polygons, alpha-shapes, convex hull algorithm... - Usage of former equivalent traits classes in different packages is now deprecated. -
      • Exact_predicates_exact_constructions_kernel now better use the static filters - which leads to performance improvements. -
      • Add an overload for the global function angle, taking three 3D points. -
      • In the 2D and 3D kernel concept, the constant Boolean Has_filtered_predicates - is now deprecated. It is now required to use Has_filtered_predicates_tag - (being either Tag_true or Tag_false). -
      • Compare_distance_2 and Compare_distance_3 provide additional operators - for 3 and 4 elements. -
      • Add intersection test and intersection computation capabilities - between an object of type Ray_3 and either an object of type Line_3, Segment_3 or Ray_3. -
      • Improve intersection test performance between an object of type Bbox_3 and an object of type - Plane_3 or Triangle_3 by avoiding arithmetic filter failures. -
      - -

      2D Envelope

      -
        -
      • Env_default_diagram_1 is deprecated, Envelope_diagram_1 should be used instead. -
      - -

      3D Envelope

      -
        -
      • A new demo program called L1_Voronoi_diagram_2 has been - introduced. It demonstrates how 2D Voronoi diagrams of points under - the L1 metric are constructed using lower envelopes. -
      - - -

      dD Kernel

      -
        -
      • Add functor Compute_coordinate_d to Kernel_d concept. -
      - -

      Geometric Object Generators

      -
        -
      • CGAL::Random uses boost::rand48 instead of std::rand. -
      • Adding to CGAL::Random a way to generate random integers. -
      • Adding generators for dD points. -
      - -

      Algebraic Foundations

      -
        -
      • Algebraic_structure_traits now provides an Inverse functor for Fields. - There is also a new global function inverse. -
      - -

      Bounding Volumes

      -
        -
      • dD Min sphere of spheres has a new traits class for the min sphere of points. -
      - -

      Triangulated Surface Mesh Simplification

      -
        -
      • The priority queue internally used to prioritize edge simplifications is no longer - a relaxed heap but a binomial heap. This fix guarantees that all edges satisfying - a simplification criteria are removed (if possible). -
      - -

      3D Boolean Operations on Nef Polyhedra

      -
        -
      • Allow construction of a 3D nef polyhedron from a 3D polyhedron with normals. -
      - -

      2D Arrangements

      -
        -
      • Fix a bug in the method insert_at_vertices of the Arrangement_2 class. -
      • Fix several bugs in the traits class Arr_Bezier_curve_traits_2 for arrangement of Bezier curves. -
      - -

      2D Minkowski Sums

      -
        -
      • A bug in the convolution method was fixed. -
      -
      - -

      Release 3.7

      -
      -

      Release date: October 2010

      - -

      -CGAL 3.7 offers the following improvements and new functionality :

      - - -

      General

      - -
        -
      • The configuration of CGAL libraries now requires CMake>=2.6. - -
      • Changes in the set of supported platforms: -
          -
        • GNU g++ 4.5 supported (with or without the compilation option - -std=c++0x). - -
        • Initial support for the option -strict-ansi of the Intel Compiler 11. - The CGAL libraries compile with that option, and most CGAL headers - have been fixed. The packages "3D Boolean Operations on Nef - Polyhedra" (Nef_3), "Convex Decomposition of Polyhedra" - (Convex_decomposition_3), and "3D Minkowski Sum of Polyhedra" - (Minkowski_sum_3) are known to still fail to compile with that - compiler flag. - -
        • The Microsoft Windows Visual C++ compiler 2010 (VC10), that was - experimentally supported by CGAL-3.6.1, is now fully supported. Note - that CMake>=2.8.2 is required for that support. - -
        • The Microsoft Windows Visual C++ compiler 2005 (VC8) is no longer - supported by the CGAL project since CGAL-3.7. - -
        • With Microsoft Windows Visual C++ (VC9 and VC10), the optional - dependencies Gmp, Mpfr, Blas, Lapack, Taucs no longer use Boost-style - name mangling. Only one variant is now provided by the CGAL Windows - installer (release, with dynamic runtime). -
        -
      • Some demos now require a version of Qt4 >= 4.3. - -
      • CGAL_PDB is no longer provided with CGAL. An alternative solution for - people interested in reading PDB files is to use ESBTL - (http://esbtl.sourceforge.net/). - -
      • Fix issues of the CGAL wrappers around the CORE library, on 64 bits - platforms. -
      - - -

      Arithmetic and Algebra

      -
        -
      • New models Algebraic_kernel_d_1 and Algebraic_kernel_d_2 for the - corresponding concepts. They provide generic support for various - coefficient types -
      - -

      Arrangements

      -
        -
      • A new model Arr_algebraic_segment_traits_2 of ArrangementTraits_2 that - supports algebraic curves of arbitrary degree in the plane -
      - - -

      2D Triangulations

      -
        -
      • The Delaunay and regular 2D triangulations now use a symbolic - perturbation to choose a particular triangulation in co-circular cases. - -
      • The return type of the template member function - insert(It beg, It end), taking an iterator range of points, - has been changed from int to std::ptrdiff_t. - -
      • Classes Triangulation_euclidean_traits_xy_3, Triangulation_euclidean_traits_yz_3 - and Triangulation_euclidean_traits_xz_3 are now model of the concept - ConstrainedTriangulationTraits_2. They can be used with and without intersection - of constraints. - -
      • 2D Delaunay and basic triangulations now provide vertex relocation by - the mean of these two new methods: move and move_if_no_collision. The - methods are also available for the hierarchy - (Triangulation_hierarchy_2). - -
      - -

      3D Triangulations

      -
        -
      • The return type of the template member function - insert(It beg, It end), taking an iterator range of points, - has been changed from int to std::ptrdiff_t. -
      • 3D Delaunay triangulations now provide vertex relocation by the mean - of these two new methods: move and move_if_no_collision. This works in - both Compact_policy and Fast_policy. -
      - -

      2D and 3D Alpha Shapes

      -
        -
      • The type int in the API has been changed to std::size_t - so that CGAL can deal with large data sets (64 bit addresses). -
      - - -

      2D Mesh Generation

      -
        -
      • The execution of the 2D mesh generator is now deterministic (same at - each run). -
      - -

      3D Mesh Generation

      -
        -
      • The efficiency of the 3D mesh generator has been improved (the number - of calls to the oracle per inserted vertex has globally decrease). - This is achieved through a slight change of the mesh generator strategy - which implies that a surface component that is not detected at the - surface mesher level will never be discovered by chance, owing to the - refinement of some tetrahedra, as it could happen before. - Please note that defining the macro - CGAL_MESH_3_USE_OLD_SURFACE_RESTRICTED_DELAUNAY_UPDATE switches back to - the old behavior. - -
      • A demo program is now available. -
      - -

      Surface Reconstruction from Point Sets

      -
        -
      • Improved performance and minor bug fix. -
      - - -

      2D Range and Neighbor Search

      -
        -
      • The type int in the API has been changed to std::size_t - so that CGAL can deal with large data sets (64 bit addresses). -
      - -
      - - - -

      Release 3.6.1

      - -
      -

      Release date: June 2010

      - -

      -This is a bug fix release. The following has been changed -since CGAL-3.6:

      - -

      General

      - -
        -
      • Fix compilation errors with recent Boost versions (since 1.40). - -
      • Initial support for the Microsoft Visual C++ compiler 10.0 (MSVC - 2010). For that support, CMake>=2.8.2 is required. - Note also that the compiler option "/bigobj" is necessary to compile - some CGAL programs with MSVC 2010. -
      - - -

      Polynomial

      -
        -
      • Fix compilation errors with the Microsoft Visual C++ compiler and the - Intel C++ compiler. -
      - -

      Polyhedron

      -
        -
      • Fix a compilation errors in demo/Polyhedron/: -
      • issue with the location of qglobal.h of Qt4 on MacOS X, -
      • missing texture.cpp, if TAUCS is used, -
      • Fix the location of built plugins of demo/Polyhedron/, when CGAL is - configured with WITH_demos=ON -
      - -

      3D Periodic Triangulations

      -
        -
      • Fixed bug in the triangulation hierarchy for periodic triangulations. -
      - -

      2D Mesh Generation

      -
        -
      • Fix a bug that lead to precondition violation. -
      • Improve the user manual about the member function is_in_domain() of the - Face type. -
      • The 2D meshing process is now deterministic (sorting of bad faces no - longer relies on pointers comparisons). -
      - -

      3D Mesh Generation

      -
        -
      • Fix a linking errors (duplicate symbols) when <CGAL/refine_mesh_3.h> is - included in different compilation units. -
      - -

      Spatial Searching

      -
        -
      • Fix a bug in <CGAL/Orthogonal_k_neighbor_search.h> when several - nearest neighbors are at the same distance from the query point. -
      - -

      IO Streams

      -
        -
      • Fix a bug in <CGAL/IO/VRML_2_ostream.h> that generated VRML 2 files with - an invalid syntax for IndexedFaceSet nodes. -
      - -

      Triangulation_2

      -
        -
      • Add missing Compare_distance_2 functor in trait classes Triangulation_euclidean_traits_xy_3 - Triangulation_euclidean_traits_yz_3 and Triangulation_euclidean_traits_xz_3. - This was preventing calling member function nearest_vertex of Delaunay_triangulation_2 - instantiated with one of these traits. -
      -
      - -

      Release 3.6

      - -
      -

      Release date: March 2010

      - -

      -CGAL 3.6 offers the following improvements and new functionality :

      - -

      General

      - -
      • Boost version 1.34.1 at least is now required.
      - - -

      Arithmetic and Algebra

      - -

      Algebraic Kernel (new package)

      - -
        -
      • This new package is targeted to provide black-box implementations of - state-of-the-art algorithms to determine, compare and approximate real - roots of univariate polynomials and bivariate polynomial systems. It - includes models of the univariate algebraic kernel concept, based on - the library RS. -
      - -

      Number Types

      - -
        -
      • Two new arbitrary fixed-precision floating-point number types have been - added: the scalar type Gmpfr and the interval type Gmpfi, based on the - MPFR and MPFI libraries respectively. -
      - - -

      Geometry Kernels

      - -

      2D and 3D Geometry Kernel

      -
        -
      • Add new do_intersect() and intersection() overloads: -
          -
        • do_intersect(Bbox_3, Bbox_3/Line_3/Ray_3/Segment_3) -
        • intersection(Triangle_3, Line_3/Ray_3/Segment_3) -
        -
      - -

      Polygons

      - -

      2D Regularized Boolean Set-Operations

      -
        -
      • Fixed General_polygon_set_2::arrangement() to return the proper type - of object. -
      - - -

      Arrangement

      - -

      2D Arrangements

      - -
      • Fixed passing a (const) traits object to the constructor of Arrangement_2. - -
      • Introduced Arrangement_2::fictitious_face(), which returns the fictitious - face in case of an unbounded arrangement. - -
      • Fixed a bug in Bezier-curve handling. - -
      • Added (back) iterator, number_of_holes(), holes_begin(), and holes_end() - to the default DCEL for backward compatibility. - -
      • Added (simple) versions of the free overlay() function. It employs the - default overlay-traits, which practically does nothing. -
      - -

      Polyhedron

      -
        -
      • Fix a compilation errors in demo/Polyhedron/: -
          -
        • issue with the location of qglobal.h of Qt4 on MacOS X, -
        • missing texture.cpp, if TAUCS is used, -
        -
      • Fix the location of built plugins of demo/Polyhedron/, when CGAL is - configured with WITH_demos=ON -
      • Fix a bug in test_facet function of the incremental builder: - the function did not test if while a new facet makes a vertex manifold, - no other facet incident to that vertex breaks the manifold property. -
      - -

      Triangulations and Delaunay Triangulations

      - -

      2D/3D Regular Triangulations

      - -
      • Weighted_point now has a constructor from Cartesian coordinates. -
      - -

      3D Triangulations

      - -
      • Regular_triangulation_3 : semi-static floating-point filters are now used - in its predicates, which can speed up its construction by a factor of about 3 - when Exact_predicates_inexact_constructions_kernel is used. - -
      • The class Regular_triangulation_filtered_traits_3 is deprecated, the class - Regular_triangulation_euclidean_traits_3 must be used instead. The - predicates of that traits will be filtered if the kernel given as template - parameter of that traits is itself a filtered kernel. - -
      • Triangulation_hierarchy_3 is now deprecated, and replaced by a simpler - CGAL::Fast_location policy template parameter of Delaunay_triangulation_3. - -
      • The old version of remove() (enabled with CGAL_DELAUNAY_3_OLD_REMOVE) - has been deleted. -
      - -

      3D Periodic Triangulations

      - -
      • New demo: 3D periodic Lloyd algorithm. - -
      • New functionality for Voronoi diagrams: dual of an edge and of a vertex, - volume and centroid of the dual of a vertex. - -
      • The package can now be used with the 3D Alpha Shapes package to compute - periodic alpha shapes. -
      - -

      3D Alpha shapes

      - -
      • The class Weighted_alpha_shape_euclidean_traits_3 is deprecated, the class - Regular_triangulation_euclidean_traits_3 must be used instead. - -
      • The package can now be used together with the 3D Periodic Triangulation - package to compute periodic alpha shapes. -
      - -

      2D/3D Triangulations, 2D Segment Delaunay Graph, 2D Apollonius Graph, - and 3D Periodic Triangulations

      - -
      • The constructor and insert function taking ranges now produce - structures whose iterator orders is now deterministic (same at each - run). -
      - - -

      Mesh Generation

      - -

      2D Mesh Generation

      - -
      • The 2D mesh generator can now be used with a constrained Delaunay - triangulation with constraints hierarchy - (Constrained_triangulation_plus_2). -
      • In some cases (refinement of a constrained edge that is on the - convex hull), the 2D mesh generator from CGAL-3.4 and CGAL-3.5 - could create invalid triangulations. This bug is now fixed. -
      - -

      3D Mesh Generation

      - -
      • The mesh generator has been enriched with an optimization phase to - provide 3D meshes with well shaped tetrahedra (and in particular no - slivers). The optimization phase involves four different optimization - processes: two global optimization processes (ODT and Lloyd), a - perturber and an exuder. Each of these processes can be activated or - not, and tuned to the users needs and to available computer resources. -
      - -

      Support library

      - -

      CGAL ipelets

      - -
      • Add support for version 7 of Ipe. -
      - -
      - - -

      Release 3.5.1

      -
      -

      Release date: December 2009

      -

      -This is a bug fix release.

      - -

      Documentation

      -
        -
      • Fixes in the documentation (the online documentation of CGAL-3.5 is now - based on CGAL-3.5.1). -
      • Fixes to the bibliographic references. -
      - -

      Windows installer

      -
        -
      • The Windows installer of CGAL-3.5.1 fixes an issue with downloading of - precompiled binaries of the external library TAUCS. -
      - -

      Bug fixes in the following CGAL packages

      -

      AABB tree

      -
        -
      • Fix a linker issue in do_intersect(Bbox_3,Bbox_3). -
      • Fix compilation issue in do_intersect(Bbox_3,Ray_3) when using the - parameters in this order. -
      -

      3D Mesh Generation

      -
        -
      • Fix a bug in initial points construction of a polyhedral surface. -
      -
      - - - -

      Release 3.5

      -
      -

      Release date: October 2009

      -

      - CGAL releases will now be published about every six months. As a transition - release, CGAL-3.5 has been developed during 9 months from the release - CGAL-3.4.

      - -

      Version 3.5 differs from version 3.4 in the platforms that are supported and - in functionality. There have also been a number of bug fixes for this release.

      - -

      General

      -
        -
      • Additional supported platforms: -
          -
        • GNU g++ 4.4 supported. -
        • Intel Compiler 11 supported on Linux -
        -
      • Fixed ABI incompatibilities when mixing CGAL and Boost Program Options - on Windows/Visual C++ (the compilation flag -D_SECURE_SCL=0 is not - longer use in Debug mode). -
      - -

      Geometry Kernels

      - -

      3D Spherical Geometry Kernel

      -
        -
      • - Add functionalities to manipulate circles, circular arcs and points - that belong to the same sphere. - -
      -

      Polygons

      - -

      2D Regularized Boolean Set-Operations

      -
        -
      • The polygon validation operations were enhanced and their interface was - improved. They are now offered as free functions and applied properly. - -
      -

      2D Straight Skeleton and Polygon Offsetting

      -
        -
      • Updated the manual to document the new partial skeletons feature - (already in the code since 3.4) - -
      - -

      Arrangements

      - -

      2D Arrangements

      -
        -
      • The member function is_at_infinity() of Arrangement_2::Vertex was - replaced by the new function is_at_open_boundary(). The former is - deprecated. While still supported in version 3.5, It will not be - supported in future releases. The member functions boundary_type_in_x() - and boundary_type_in_y() were permanently replaced by the functions - parameter_space_in_x() and parameter_space_in_y(), respectively. The 2 - new functions return an enumeration of a new type, namely - Arr_parameter_space. - -
      • The tags in the geometry traits that indicate the type of boundary of - the embedding surface were replaced by the following new tags: - Arr_left_side_tag - Arr_bottom_side_tag - Arr_top_side_tag - Arr_right_side_tag - In addition, the code was change, and now it is possible not to - indicate the tags at all. Default values are assumed. This however will - produce warning messages, and should be avoided. - -
      • All operations of the geometry traits-class were made 'const'. This - change was reflected in the code of this package and all other packages - that are based on it. Traits classes that maintain state, should - declare the data members that store the state as mutable. - -
      -

      Envelopes of Surfaces in 3D

      -
        -
      • A few bugs in the code that computes envelopes were fixed, in - particular in the code that computes the envelopes of planes. - -
      - -

      Triangulations and Delaunay Triangulations

      - -

      3D Periodic Triangulations (new package)

      - -
        -
      • This package allows to build and handle triangulations of point sets in - the three dimensional flat torus. Triangulations are built - incrementally and can be modified by insertion or removal of - vertices. They offer point location facilities. - -
      - -

      Mesh Generation

      - -

      Surface Reconstruction from Point Sets (new package)

      -
        -
      • This CGAL package implements an implicit surface reconstruction method: - Poisson Surface Reconstruction. The input is an unorganized point set - with oriented normals. - -
      -

      3D Mesh Generation (new package)

      -
        -
      • This package generates 3 dimensional meshes. It computes isotropic - simplicial meshes for domains or multidomains provided that a domain - descriptor, able to answer queries from a few different types on the - domain, is given. In the current version, Mesh_3 generate meshes for - domain described through implicit functional, 3D images or polyhedral - boundaries. The output is a 3D mesh of the domain volume and conformal - surface meshes for all the boundary and subdividing surfaces. - -
      -

      Geometry Processing

      - -

      Triangulated Surface Mesh Simplification

      - -
        -
      • BREAKING API change in the passing of the visitor object. - -
      • Fixed a bug in the link_condition test - -
      • Added a geometric test to avoid folding of facets - -
      • Fixed a bug in the handling of overflow in the LindstromTurk - computations - -
      • Updated the manual to account for the new visitor interface - -
      -

      Point Set Processing (new package)

      - -
        -
      • This packages implements a set of algorithms for analysis, processing, - and normal estimation and orientation of point sets. - -
      - -

      Spatial Searching and Sorting

      - -

      AABB tree (new package)

      - -
        -
      • This package implements a hierarchy of axis-aligned bounding boxes (a - AABB tree) for efficient intersection and distance computations between - 3D queries and sets of input 3D geometric objects. - -
      -

      Support Library

      - -

      CGAL_ipelets (new package):

      -
        -
      • Object that eases the writing of Ipe's plugins that use CGAL. - Plugins for CGAL main 2D algorithm are provided as demo. - - -
      -
      - - -

      Release 3.4

      -
      -

      Release date: January 2009

      - -

      Version 3.4 differs from version 3.3.1 in the platforms that are supported and -in functionality. There have also been a number of bug fixes for this release. -

      - -

      General

      -
        -
      • GNU g++ 4.3 supported. Support for g++ 3.3 is dropped. -
      • Visual 9 supported. Support for Visual 7 is dropped. - -
      • Boost version 1.33 at least is now required. -
      • CGAL now depends on Boost.Threads, which implies to link against - a compiled part of Boost. - -
      • The new macro CGAL_NO_DEPRECATED_CODE can be defined to disable deprecated code, - helping users discover if they rely on code that may be removed in - subsequent releases. - -
      • Assertion behaviour: - It is not possible anymore to set the CONTINUE mode for assertion failures. - Functions that allow to change the assertion behaviour are now declared in <CGAL/assertions_behaviour.h>. - -
      • Qt3 based demos are still there but the documentation has been removed as the CGAL::Qt_Widget will be deprecated. - -
      • Qt4 based demos use the Qt GraphicsView framework and the libQGLViewer. -
      - -

      Installation

      - -
        -
      • install_cgal has been replaced by CMake. -
      - - -

      Polynomial (new package)

      -
        -
      • This package introduces a concept Polynomial_d, a concept for multivariate polynomials in d variables. -
      - - -

      Modular Arithmetic (new package)

      -
        -
      • This package provides arithmetic over finite fields. -
      - - -

      Number Types

      -
        -
      • the counter Interval_nt::number_of_failures() has been removed, replaced by - a profiling counter enabled with CGAL_PROFILE. - - -
      • Fix of a bug in CORE/Expr.h; as a consequence, the arrangement demo works properly when handling - arrangements of conics, for example, when defining an arc with 5 points. - -
      - - - -

      3D Spherical Geometry Kernel (new package)

      -
        -
      • This package is an extension of the linear CGAL Kernel. It offers functionalities on spheres, - circles, circular arcs and line segments in the 3D space. -
      - -

      Linear Kernel

      -
        -
      • We recommend that you use the object_cast() function instead of assign() - to extract an object from a CGAL::Object, for efficiency reasons. -
      • The Kernel archetypes provided by the 2D/3D linear kernel have been removed. -
      • The deprecated linear kernel functors Construct_supporting_line_2 and - Construct_supporting_line_3 have been removed. -
      • Ambiant_dimension and Feature_dimenison have been added to retrieve the - potentially compile-time dimension of a space or of an object. -
      • barycenter() functions have been added. - -
      • The geometric object Circle_3 as well as predicates and constructions have been added to the kernel - -
      • The missing intersection/do_intersect between Line_3 and Line_3 has been added as well. -
      - - -

      3D Triangulations

      -
        -
      • Removed the deprecated functions Cell:mirror_index() and Cell::mirror_vertex(). -
      • Derecursification of two functions that in some cases lead to stack overflows -
      - - -

      3D Nef Polyhedron

      -
        -
      • n-ary union/intersection -
      • intersection with halfspace under standard kernel -
      • constructor for polylines -
      - - -

      CGAL and the Qt4 GraphicsView (new package)

      -
        -
      • 2D CGAL Kernel objects and many data structures have can be rendered in a QGraphicsView -
      - -

      STL Extensions:

      -
        -
      • The functor adaptors for argument binding and composition - (bind_*, compose, compose_shared, swap_*, negate, along with the helper - functions set_arity_* and Arity class and Arity_tag typedefs) which were provided - by <CGAL/functional.h> have been removed. Please use the better boost::bind - mecanism instead. The concept AdaptableFunctor has been changed accordingly - such that only a nested result_type is required. -
      • The accessory classes Twotuple, Threetuple, Fourtuple and Sixtuple are also - deprecated (use CGAL::array instead). -
      • CGAL::Triple and CGAL::Quadruple are in the process of being replaced by - boost::tuple. As a first step, we strongly recommend that you replace - the direct access to the data members (.first, .second, .third, .fourth), - by the get<i>() member function; and replace the make_triple and make_quadruple - maker functions by make_tuple.
        - This way, in a further release, we will be able to switch to boost::tuple more easily. -
      • The class CGAL::Uncertain<> has been documented. It is typically used to report - uncertain results for predicates using interval arithmetic, and other filtering - techniques. -
      - - -

      2D Arrangements

      -
        -
      • Changed the name of the arrangement package from Arrangement_2 to Arrangement_on_surface_2 - to reflect the potential capabilities of the package to construct and maintain arrangements - induced by curves embedded on two dimensional surfaces in three space. Most of these capabilities - will become available only in future releases though. -
      • Enhanced the geometry traits concept to handle arrangements embedded on surfaces. Each geometry-traits - class must now define the 'Boundary_category' tag. -
      • Fixed a bug in Arr_polyline_traits_2.h, where the operator that compares two curves failed to evaluate - the correct result (true) when the curves are different, but their graphs are identical. -
      • Permanently removed IO/Arr_postscript_file_stream.h and IO/Polyline_2_postscript_file_stream.h, - as they depend on obsolete features and LEDA. -
      • Fixed several bugs in the arrangement demo and enhanced it. e.g., fixed background color change, - allowed vertex coloring , enabled "smart" color selection, etc. -
      • Enhanced the arrangement demo with new features, such as allowing the abortion of the merge function - (de-select), updated the how-to description, etc. -
      • Replace the functions CGAL::insert_curve(), CGAL::insert_curves(), CGAL::insert_x_monotone_curve(), - and CGAL::insert_x_monotone_curves() with a single overloaded function CGAL::insert(). The former - 4 functions are now deprecated, and may no longer be supported in future releases. -
      - -

      Envelopes of Surfaces in 3D

      - -
        -
      • Fixed a bug in the computation of the envelope of unbounded planes caused by multiple removals - of vertices at infinity. -
      - -

      2D Regularized Boolean Set-Operations

      -
        -
      • Fixed a bug in connect_holes() that caused failures when connecting holes touching the outer boundary. -
      • Fixed the concept GeneralPolygonSetTraits_2. Introduced two new concepts GpsTraitsGeneralPolygon_2 - and GpsTraitsGeneralPolygonWithHoles_2. Fixed the definition of the two nested required types Polygon_2 - and Polygon_with_holes_2 of the GeneralPolygonSetTraits_2 concept. They must model now the two new - concepts above. -
      • Added a default template parameter to 'General_polygon_set_2' to allow users to pass their specialized - DCEL used to instantiate the underlying arrangement. -
      • Enhanced the BOP demo to use multiple windows. -
      - -

      2D Minkowski Sums

      -
        -
      • Fixed a few bugs in the approximate offset function, making it robust to highly degenerate inputs. -
      • Fixed a bug in the exact Minkowski sum computation when processing degenerate inputs that induce overlapping - of contiguous segments in the convolution cycles. -
      • Optimized the approximate offset function (reduced time consumption up to a factor of 2 in some cases). -
      • Added functionality to compute the offset (or to approximate the offset) of a Polygon_with_holes_2 - (and not just of a Polygon_2). -
      • Added the functionality to compute (or to approximate) the inner offset of a polygon. -
      - -
      - - -

      Release 3.3.1

      -
      -

      Release date: August 2007

      - -

      This is a bug fix release. -

      - -

      General

      -
        -
      • Intel C++ 9 was wrongly recognized as unsupported by install_cgal. -
      • Added autolink (for Visual C++) for the CGALImageIO and CGALPDB libraries. -
      • Fixed bug in Memory_sizer when using more than 4GB of memory (64bit). -
      - -

      Number Types

      -
        -
      • Fixed bug in FPU rounding mode macros (affected only the alpha architecture). -
      • Fixed bug in MP_Float constructor from double for some particular values. -
      • Fixed bug in to_double(Lazy_exact_nt) sometimes returning NaN. -
      - -

      Kernel

      -
        -
      • Fixed forgotten derivation in Circular_kernel_2::Has_on_2 -
      • Added some missing functions in Bbox_3 compared to Bbox_2. -
      - -

      Skin Surface Meshing

      -
        -
      • The new Skin Surface Meshing package had been forgotten in the list of - changes and the release announcement of CGAL 3.3: - This package allows to build a triangular mesh of a skin surface. - Skin surfaces are used for modeling large molecules in biological computing. -
      - -

      Arrangements

      -
        -
      • Fixed a bug in the Arrangement_2 package in dual arrangement representation - for Boost graphs when reporting all halfedges of a face. -
      • Fixed a bug in the Arrangement sweep-line when using a specific polyline - configuration. -
      • Fixed bug in Arrangement_2 in walk along a line point location for unbounded curves. -
      • Fixed bug in aggregated insertion to Arrangement_2. -
      • Fixed bug in Arrangment_2 class when inserting an unbounded curve from an existing vertex. -
      • Fixed bug when dealing with a degenerate conic arc in Arr_conic_traits_2 of - the Arrangment package, meaning a line segment which is part of a degenerate - parabola/hyperbola. -
      • Fixed bug in the Bezier traits-class: - properly handle line segments. - properly handle comparison near a vertical tangency. -
      - -

      2D Polygon

      -
        -
      • Fixed bug in degenerate case of Polygon_2::is_convex() for equal points. -
      - -

      2D Triangulations

      -
        -
      • Fixed bug in Regular_triangulation_2. -
      - -

      3D Triangulations

      -
        -
      • Added a circumcenter() function in the default Cell type parameter - Triangulation_ds_cell_base_3, so that the .dual() member function of - Delaunay still work as before, without requiring the explicit use of - Triangulation_cell_base. -
      • Added missing operator->() to Facet_circulator. -
      - -

      Interpolation

      -
        -
      • Fixed bug in Interpolation 3D about the normalization coefficient initialization. -
      - -

      3D Boolean Operations on Nef Polyhedra

      -
        -
      • Fixed bug in construction of Nef_polyhedron_3 from off-file. Now, always the - inner volume is selected. -
      • Fixed bug in conversion from Nef_polyhedron_3 to Polyhedron_3. Polyhedron_3 was not cleared - at the beginning. -
      • Fixed bug in Nef_polyhedron_3 in update of indexes for construction of external structure. -
      - -

      Third Party Libraries Shipped with CGAL

      -
        -
      • TAUCS supports now 64 bits platforms. -
      • CAUTION: Since version 3.3.1, CGAL is no longer compatible with the official - release of TAUCS (currently 2.2). Make sure to use the version - modified by the CGAL project and available from the download section - of http://www.cgal.org. -
      - -
      - - - -

      Release 3.3

      -
      -

      Release date: May 2007

      - -

      -Version 3.3 differs from version 3.2.1 in the platforms that are supported and -in functionality. There have also been a number of bug fixes for this release. -

      - -

      Additional supported platforms -

        -
      • GNU g++ 4.1 and 4.2 -
      • Intel C++ compiler 9 -
      • Microsoft Visual C++ compiler 8.0 -
      - -

      The following platforms are no longer supported: - -

        -
      • Intel 8 -
      - -

      CGAL now supports Visual C++ "Checked iterators" as well as the debug mode -of GNU g++'s STL (-D_GLIBCXX_DEBUG).

      - -

      CGAL now works around the preprocessor macros 'min' and 'max' defined -in <windows.h> which were clashing with min/max functions. -

      - - -

      Installation

      - -
        -
      • On Windows the libraries built in Developer Studio now have names - which encode the compiler version, the runtime and whether it was - built in release or debug mode. The libraries to link against are - chosen with linker pragmas in header files. -
      • On all platforms but Windows shared and static versions of the libraries are generated -
      - -

      Manuals

      -
        -
      • The Package Overview page now also hosts the precompiled demos. -
      - -

      Algebraic Foundations

      - - -

      -

        -
      • Algebraic Foundations (new package)
        - -This package defines what algebra means for CGAL, in terms of concepts, classes and functions. The main features are: (i) explicit concepts for interoperability of types (ii) separation between algebraic types (not necessarily embeddable into the reals), and number types (embeddable into the reals). - -

        -

      • Number Types
        - Fixed_precision_nt and Filtered_exact number types have been removed. -
      - -

      Kernels

      - -

      -

        -
      • 2D Circular Kernel
        -Efficiency improved through geometric filtering of predicates, introduced with - the filtered kernel Filtered_bbox_circular_kernel_2<.>, and also chosen for the - predefined kernel Exact_circular_kernel_2. - -
      • Linear Kernel
        - Exact_predicates_exact_constructions_kernel memory and run-time improvements - through usage of lazy geometric constructions instead of lazy arithmetic. -
      - -

      Data Structures and Algorithms

      - -

      -

        -
      • Surface Mesh Simplification (new package)
        - - This package provides a mesh simplification framework using edge collapse - operations, and provides the Turk/Lindstrom simplification algorithm. - -

        -

      • Skin Surface Meshing (new package)
        - - This package allows to build a triangular mesh of a skin surface. - Skin surfaces are used for modeling large molecules in biological - computing. The surface is defined by a set of balls, representing - the atoms of the molecule, and a shrink factor that determines the - size of the smooth patches gluing the balls together. - -

        -

      • Estimation of Local Differential Properties (new package)
        - - This package allows to compute local differential quantities of a surface from a point sample - -

        -

      • Approximation of Ridges and Umbilics on Triangulated Surface Meshes (new package)
        - - This package enables the approximation of differential features on - triangulated surface meshes. Such curvature related features are - lines: ridges or crests, and points: umbilics. - -

        -

      • Envelopes of Curves in 2D (new package)
        - - This package contains two sets of functions that construct the lower and upper envelope diagram - for a given range of bounded or unbounded curves. - -

        -

      • Envelopes of Surfaces in 3D (new package)
        - - This package contains two sets of functions that construct the lower and upper envelope diagram - for a given range of bounded or unbounded surfaces. The envelope diagram is realized as a - 2D arrangement. - -

        -

      • Minkowski Sums in 2D (new package)
        - - This package contains functions for computing planar Minkowski sums of two closed polygons, - and for a polygon and a disc (an operation also known as offsetting or dilating a polygon). - The package also contains an efficient approximation algorithm for the offset computation, - which provides a guaranteed approximation bound while significantly expediting the running - times w.r.t. the exact computation procedure. - -

        -

      • Surface Mesh Parametrization
        - - Added Jacobi and SSOR preconditioners to OpenNL solver, which makes it - much faster and more stable. - -

        -

      • 2D Arrangements
        - -
          -
        • Added support for unbounded curves. -
        • Added a traits class that supports bounded and unbounded linear objects, - namely lines, rays and line segments. -
        • Added traits classes that handle circular arcs based on the circular kernel. -
        • Added a traits class that supports Bezier curves. -
        • Enhanced the traits class that supports rational functions to - handle unbounded (as well as bounded) arcs -
        • Added a free function called decompose() that produces the symbolic vertical decomposition of a - given arrangement, performing a batched vertical ray-shooting query from all arrangement vertices. -
        • Fixed a memory leak in the sweep-line code. -
        • Fixed a bug in computing the minor axis of non-degenerate hyperbolas. -
        - -
      • Boolean Set Operations
        -
          -
        • Added the DCEL as a default template parameter to the General_polygon_set_2 and Polygon_set_2 classes. - This allows users to extend the DCEL of the underlying arrangement. -
        • Added a function template called connect_holes() that connects the holes in a given polygon with holes, - turning it into a sequence of points, where the holes are connceted to the outer boundary using - zero-width passages. -
        • Added a non-const function member to General_polygon_set_2 that obtains the underlying arrangement. -
        - -

        -

      • 2D and 3D Triangulations
        -
          -
        • The constructors and insert member functions which take an iterator range perform spatial sorting - in order to speed up the insertion. -
        - - -

        -

      • Optimal Distances -
        -
          -
        • Polytope_distance_d: - has support for homogeneous points; bugfix in fast exact version. -
        - - -

        -

      • Bounding Volumes -
        -
          -
        • Min_annulus_d has support for homogeneous points; bugfix in fast exact version. -
        - -
      - -

      Support Library

      - -
        -
      • CGAL and the Boost Graph Library (BGL) (new package)
        - -This package provides the glue layer for several CGAL data structures such that -they become models of the BGL graph concept. - -

        -

      • Spatial Sorting (new package)
        - -This package allows to sort points and other objects along a Hilbert curve -which can improve the performance of algorithms like triangulations. -It is used by the constructors of the triangulation package which have -an iterator range of points as argument. - -

        -

      • Linear and Quadratic Programming Solver (new package)
        -This package contains algorithms for minimizing linear and -convex quadratic functions over polyhedral domains, described by linear -equations and inequalities. -
      -
      - - - - - -

      Release 3.2.1

      -
      -

      Release date: July 2006

      - -

      -This is a bug fix release -

      - -

      Number Types

      -
        -
      • Fix MP_Float constructor which crashed for some values. -
      - -

      Kernel

      -
        -
      • Rename Bool to avoid a clash with a macro in X11 headers. -
      -

      Arrangement

      - -
        -
      • Derived the Arr_segment_traits_2 Arrangement_2 traits class from the parameterized Kernel. - This allows the use of this traits class in an extended range of applications that require - kernel objects and operations on these objects beyond the ones required by the Arrangement_2 - class itself. -
      • Fixed a compilation bug in the code that handles overlay of arrangements instantiated with - different DCEL classes. -
      • Fixed a couple of bugs in the implementation of the Trapezoidal RIC point-location strategy -
      - -

      Triangulation, Alpha Shapes

      -
        -
      • Qualify calls to filter_iterator with "CGAL::" to avoid overload ambiguities with - Boost's filter_iterator. -
      - -

      Surface Mesher

      -
        -
      • Fixed a bug in iterators of the class template Surface_mesh_complex_2_in_triangulation_3 -
      - -

      Surface Mesh Parametrisation

      -
        -
      • Updated the precompiled taucs lib -
      -

      Kinetic Data Structures

      -
        -
      • Fixed problems caused by old versions of gcc being confused by operator! and operator int() -
      • Added point removal support to the Active_objects_vector -
      - -
      - - -

      Release 3.2

      -
      -

      Release date: May 2006

      - -

      -Version 3.2 differs from version 3.1 in the platforms that are supported and -in functionality. There have also been a number of bug fixes for this release. -

      - -

      The following platforms are no longer supported: - -

        -
      • SunPro CC versions 5.4 and 5.5 on Solaris -
      • SGI Mips Pro -
      - -

      -For Visual C++ the installation scripts choose the multi-threaded dynamically -linked runtime (/MD). Before it was the single-threaded static runtime (/ML).

      - - -

      Installation

      - -
        -
      • The install tool tries to find third party libraries - at "standard" locations. -
      • Installers for Apple, Windows, and rpms. -
      - -

      Manuals

      -
        -
      • User and Reference manual pages of a package are in the same chapter -
      - - -

      Kernels

      - -

      -

        -
      • 2D Circular Kernel (new package)
        -This package is an extension of the linear CGAL Kernel. It offers functionalities -on circles, circular arcs and line segments in the plane. -
      - -

      Data Structures and Algorithms

      - -

      -

        -
      • 2D Regularized Boolean Set-Operations (new package)
        - -This package consists of the implementation of Boolean set-operations -on point sets bounded by weakly x-monotone curves in 2-dimensional -Euclidean space. In particular, it contains the implementation of -regularized Boolean set-operations, intersection predicates, and point -containment predicates. - -

        -

      • 2D Straight Skeleton and Polygon Offsetting (new package)
        - -This package implements an algorithm to construct a halfedge data -structure representing the straight skeleton in the interior of 2D -polygons with holes and an algorithm to construct inward offset -polygons at any offset distance given a straight skeleton. - - -

        -

      • 2D Voronoi Diagram Adaptor (new package)
        - -This package provides an adaptor that adapts a -2-dimensional triangulated Delaunay graph to the corresponding -Voronoi diagram, represented as a doubly connected edge list (DCEL) -data structure. The adaptor has the ability to automatically -eliminate, in a consistent manner, degenerate features of the Voronoi -diagram, that are artifacts of the requirement that Delaunay graphs -should be triangulated even in degenerate configurations. Depending on -the type of operations that the underlying Delaunay graph supports, -the adaptor allows for the incremental or dynamic construction of -Voronoi diagrams and can support point location queries. - - -

        -

      • 3D Surface Mesher (new package)
        - -This package provides functions to generate surface meshes that -interpolate smooth surfaces. The meshing algorithm is based on -Delaunay refinement and provides some guarantees on the resulting -mesh: the user is able to control the size and shape of the mesh -elements and the accuracy of the surface approximation. There is no -restriction on the topology and number of components of input -surfaces. The surface mesher may also be used for non smooth surfaces -but without guarantee. - -

        -Currently, implementations are provided for implicit surfaces -described as the zero level set of some function and surfaces -described as a gray level set in a three-dimensional image.

        - - -

        -

      • 3D Surface Subdivision Methods (new package)
        - -Subdivision methods recursively refine a control mesh and generate -points approximating the limit surface. This package consists of four -popular subdivision methods and their refinement hosts. Supported -subdivision methods include Catmull-Clark, Loop, Doo-Sabin and sqrt(3) -subdivisions. Their respective refinement hosts are PQQ, PTQ, DQQ and -sqrt(3) refinements. Variations of those methods can be easily -extended by substituting the geometry computation of the refinement -host. - - -

        -

      • Planar Parameterization of Triangulated Surface Meshes (new package)
        - -Parameterizing a surface amounts to finding a one-to-one mapping from -a suitable domain to the surface. In this package, we focus on -triangulated surfaces that are homeomorphic to a disk and on piecewise -linear mappings into a planar domain. This package implements some of -the state-of-the-art surface mesh parameterization methods, such as -least squares conformal maps, discrete conformal map, discrete -authalic parameterization, Floater mean value coordinates or Tutte -barycentric mapping. - - -

        -

      • Principal Component Analysis (new package)
        - -This package provides functions to compute global informations on the -shape of a set of 2D or 3D objects such as points. It provides the -computation of axis-aligned bounding boxes, centroids of point sets, -barycenters of weighted point sets, as well as linear least squares -fitting for point sets in 2D, and point sets as well as triangle sets -in 3D. - - -

        -

      • 2D Placement of Streamlines (new package)
        - -Visualizing vector fields is important for many application domains. A -good way to do it is to generate streamlines that describe the flow -behaviour. This package implements the "Farthest Point Seeding" -algorithm for placing streamlines in 2D vector fields. It generates a -list of streamlines corresponding to an input flow using a specified -separating distance. The algorithm uses a Delaunay triangulation to -model objects and adress different queries, and relies on choosing the -centers of the biggest empty circles to start the integration of the -streamlines. - - -

        -

      • Kinetic Data Structures (new package)
        - -Kinetic data structures allow combinatorial structures to be -maintained as the primitives move. The package provides -implementations of kinetic data structures for Delaunay triangulations -in two and three dimensions, sorting of points in one dimension and -regular triangulations in three dimensions. The package supports exact -or inexact operations on primitives which move along polynomial -trajectories. - - -

        -

      • Kinetic Framework (new package)
        - -Kinetic data structures allow combinatorial geometric structures to be -maintained as the primitives move. The package provides a framework to -ease implementing and debugging kinetic data structures. The package -supports exact or inexact operations on primitives which move along -polynomial trajectories. - - -

        -

      • Smallest Enclosing Ellipsoid (new package)
        - -This algorithm is new in the chapter Geometric Optimisation. - -

        -

      • 2D Arrangement (major revision)
        - -This package can be used to construct, maintain, alter, and display -arrangements in the plane. Once an arrangement is constructed, the -package can be used to obtain results of various queries on the -arrangement, such as point location. The package also includes generic -implementations of two algorithmic frameworks, that are, computing the -zone of an arrangement, and line-sweeping the plane, the arrangements -is embedded on. - -

        -Arrangements and arrangement components can also be extended to store -additional data. An important extension stores the construction -history of the arrangement, such that it is possible to obtain the -originating curve of an arrangement subcurve.

        - - -

        -

      • Geometric Optimisation (major revision)
        - -The underlying QP solver which is the foundation for several algorithms -in the Geometric Optimisation chapter has been completely rewritten. - -

        -

      • 3D Triangulation (new functionality)
        - -Regular_triangulation_3 now offers vertex removal. - -
      - - -
      - -

      Release 3.1

      -
      -

      Release date: December 2004

      -

      Version 3.1 differs from version 3.0 in the platforms that are supported and -in functionality. There have also been a number of bug fixes for this release.

      - - -

      -Additional supported platforms: -

        -
      • MS Visual C++, version 7.3. and 8.0 -
      • Intel 8.0 -
      • SunPro CC versions 5.4 and 5.5 on Solaris -
      • GNU g++ versions 3.4 on Linux, Solaris, Irix, cygwin, FreeBSD, and MacOS X -
      • Darwin (MacOS X) and IA64/Linux support. -
      -

      -The following platforms are no longer supported: -

        -
      • MS Visual C++, version 7.0 -
      - -

      -The following functionality has been added or changed:

      - -

      All

      -
        -
      • The CORE 1.7 library for exact - real arithmetic. -
      • Updated GMP to 4.1.3. -
      • Added Mpfr a library for multiple-precision floating-point computations with exact rounding. -
      • Added Boost 1.32.0 (only include files). -
      - -

      Installation

      -
        -
      • new option --disable-shared to omit building libCGAL.so. -
      - - -

      Manuals

      -
        -
      • Merged all major manuals in one multi-part manual, which provides - now cross-links between the CGAL Kernel, the CGAL Basic Library, - and the CGAL Support Library HTML manuals. - -
      • Improved layout. -
      - -

      Kernels

      - -
        -
      • Improved efficiency of filtered kernels. -
      • More predicates and constructions. -
      - - -

      Basic Library

      - - -
        -
      • 2D Segment Voronoi Diagram (new package)
        - -A data structure for Voronoi diagrams of segments in the plane under the Euclidean metric. The Voronoi edges -are arcs of straight lines and parabolas. The algorithm provided in this package is incremental. -
        • - -
      • 2D Conforming Triangulations and Meshes (new package)
        - -An implementation of Shewchuk's algorithm to construct conforming triangulations and 2D meshes. -
        • - - - -
      • 3D Boolean Operations on Nef Polyhedra (new package)
        -A new class (Nef_polyhedron_3) representing 3D Nef polyhedra, a - boundary representation for cell-complexes bounded by halfspaces - that supports boolean operations and topological operations in full - generality including unbounded cells, mixed dimensional cells (e.g., - isolated vertices and antennas). Nef polyhedra distinguish between - open and closed sets and can represent non-manifold geometry. - -
        • - -
      • 2D and Surface Function Interpolation (new package)
        - -This package implements different methods for scattered data interpolation: Given -measures of a function on a set of discrete data points, the task is -to interpolate this function on an arbitrary query point. The package -further offers functions for natural neighbor interpolation. - -
        • - -
      • Planar Nef polyhedra embedded on the sphere (new package)
        - A new class (Nef_polyhedron_S2) designed and supported mainly to - represent sphere neighborhoods around vertices of the three- - dimensional Nef polyhedra. -
        • - -
      • Box_intersection_d (new package)
        - - A new efficient algorithm for finding all intersecting pairs for - large numbers of iso-oriented boxes, i.e., typically these will be - bounding boxes of more complicated geometries. Useful for (self-) - intersection tests of surfaces etc. -
        • - - -
      • 2D Snap Rounding (new package)
        - -Snap Rounding is a well known method for converting -arbitrary-precision arrangements of segments into a fixed-precision -representation. In the study of robust geometric -computing, it can be classified as a finite precision approximation -technique. Iterated Snap Roundingis a modification -of Snap Rounding in which each vertex is at least half-the-width-of-a-pixel away -from any non-incident edge. This package supports both -methods. -
        • - -
      • 3D Triangulations - -
          -
        • Triangulation_3: added operator==(),removed push_back() and copy_triangulation(). -
        • Delaunay_3 : added nearest_vertex(), move_point(), vertices_in_conflict(). -
        • Regular_3 : added filtered traits class, and nearest_power_vertex(). -
        - - -
      • Planar_map and Arrangement_2 - -
          -
        • The interface of the two traits functions that compute the intersection of two given curves changed. The functions nearest_intersection_to_right() and nearest_intersection_to_left() return an object of type CGAL::Object that represents either an empty intersection, a point, or an overlapping subcurve. -
        • Requirements to define two binary tags were added to the traits concept of the Planar_map as follows: -Has_left_category - indicates whether the functions curves_compare_y_at_x_left() and nearest_intersection_to_left() are implemented in the traits model. -Has_reflect_category - indicates whether the functions point_reflect_in_x_and_y() and curve_reflect_in_x_and_y() are implemented in the traits model. They can be used as an alternative to the two function in the previous item. -
        • A new constructor of the Segment_cached_2 type that represents a segment in the Arr_segment_cached_traits_2 traits class was introduced. The new constructor accepts the segment endpoints as well as the coefficients of the underlying line. -
        • A new version of the conic-arc traits, based on CORE version 1.7 was introduced. This new traits class makes use of CORE's rootOf() operator to compute the intersection points in the arrangement, making its code much simpler and more elegant than the previous version. In addition, new constructors for conic arcs are provided. The new traits class usually performs about 30% faster than the version included in CGAL 3.0 -
        • The traits class that handles continuous piecewise linear curves, namely Arr_polyline_traits_2, was rewritten. The new class is parametrized with a traits class that handles segments, say Segment_traits. The polyline curve defined within the Arr_polyline_traits_2 class is implemented as a vector of segments of type Segment_traits::Curve_2. -
        • A meta traits class, namely Arr_curve_data_traits_2, that extends the curve type of the planar-map with arbitrary additional data was introduced. It should be instantiated with a regular traits-class and a class that contains all extraneous data associated with a curve. -
        • The class that represents the trapezoidal-decomposition point location strategy was renamed to Pm_trapezoid_ric_point_location. -
        • The Arrangement demo was rewritten. It covers many more features, has a much better graphical user interface, and comes with online documentation. -
        • Few bugs in the sweep-line module related to overlapping vertical segments were fixed. This module is used by the aggregate insert method that inserts a collection of curves at once. -
        - - -
      • Triangulation_2 - -
          -
        • added a filtered trait class in the regular triangulation -
        • added split and join operations in the triangulation data structure class -
        - -
      • Alpha_shapes_3 - -
          -
        • major changes in the implementation of the class Alpha_shapes_3. -
        • New implementation results in a true GENERAL mode - allowing null and negative alpha-values. It also fixed the edges classification bug - and introduces a classification of vertices. -
        - -
      • Min_ellipse_2 - -
          -
        • made access to approximate double representation public -
        • fixed bugs in conversion to double representation -
        • added is_circle() method -
        • minor performance improvements -
        - -
      • Min_sphere_of_spheres_d: - -
          -
        • The models - - Min_sphere_of_spheres_d_traits_2<K,FT,UseSqrt,Algorithm>, - Min_sphere_of_spheres_d_traits_3<K,FT,UseSqrt,Algorithm>, and - Min_sphere_of_spheres_d_traits_d<K,FT,Dim,UseSqrt,Algorithm> - - of concept MinSphereOfSpheresTraits now represent a sphere - as a std::pair<Point,Radius> (and not any more as a - CGAL::Weighted_point<Point,Weight>) -
        • Internal code cleanup; in particular, implementation details - don't pollute the namespace CGAL anymore -
        - - -
      • Polyhedron_3 - -
          -
        • New Tutorial on CGAL Polyhedron for Subdivision Algorithms with - interactive demo viewer in source code available. - -
        • Added example program for efficient self-intersection test. - - Added small helper functions, such as vertex_degree, facet_degree, - edge_flip, and is_closed. -
        - -
      • Apollonius Graph (Voronoi of Circles) - -
          -
        • Reduced memory requirements by approximately a factor of two. -
        - -
      - -
      - - -

      Release 3.0.1

      -
      -

      Release date: February 2004

      - -

      This is a bug-fix release. -No new features have been added in 3.0.1. Here is the list of bug-fixes.

      - -

      Polyhedral Surface

      - -
        -
      • Fixed wrong include files for output support. Added example. -
      - -

      Planar_map

      - -
        -
      • Fixed the so called "Walk-along-a-line" point-location strategy to - correctly handle a degenerate case. -
      - -

      2D Triangulation

      - -
        -
      • added missing figure in html doc -
      • in Line_face_circulator_2.h:
        - Fixed changes made to support handles with a typedef to iterator. - The fix concerns operator== and !=. -
      - -

      Alpha_shapes_3

      - -
        -
      • fixed classify member function for edges. -
      - - -

      Number types

      - -
        -
      • Lazy_exact_nt: -
          -
        • added the possibility to select the relative precision of - to_double() (by default 1e-5). This should fix reports - that some circumcenters computations have poor coordinates, - e.g. nan). -
        • when exact computation is triggered, the interval is recomputed, - this should speed up some kinds of computations. -
        -
      • to_interval(Quotient<MP_Float>): avoid spurious overflows. -
      - -

      Kernel

      - -
        -
      • - missing acknowledgment in the manual and minor clarification of - - intersection() documentation. -
      - -
      - -

      Release 3.0

      -
      - -

      Release date: October 2003

      - -

      Version 3.0 differs from version 2.4 in the platforms that are supported and -in functionality. There have also been a number of bug fixes for this release.

      - -

      The license has been changed to either the LGPL (GNU Lesser General Public -License v2.1) or the QPL (Q Public License v1.0) depending on each package. -So CGAL remains free of use for you, if your usage meets the criteria of these -licenses, otherwise, a commercial license has to be purchased from -GeometryFactory.

      - -

      -Additional supported platforms: -

        -
      • MS Visual C++, version 7.1. -
      • SunPro CC versions 5.4 and 5.5 on Solaris -
      • GNU g++ versions 3.2 and 3.3 on Linux, Solaris, Irix, cygwin, and FreeBSD. -
      • MipsPRO CC 7.30 and 7.40 with both the n32 and n64 ABIs. -
      -

      -The following platforms are no longer supported: -

        -
      • MS Visual C++, version 6. -
      • GNU g++ 2.95.2 (2.95.3 is still supported) -
      • Kai C++ and Borland C++, all versions -
      - -

      -The following functionality has been added or changed:

      - -All -

        -
      • The CORE library for exact - computations is now distributed as part of CGAL as well. -
      - - -

      Kernels

      - - -
        -
      • 3 typedefs have been added to ease the choice of a robust and fast kernel: -
          -
        • Exact_predicates_inexact_constructions_kernel -
        • Exact_predicates_exact_constructions_kernel -
        • Exact_predicates_exact_constructions_kernel_with_sqrt -
        -
      • Progress has been made towards the complete adaptability and - extensibility of our kernels. -
      • New faster Triangle_3 intersection test routines. -
        (see Erratum) -
      • Added a Kernel concept archetype to check that generic algorithms - don't use more functionality than they should. -
      • A few more miscellaneous functions. -
      - -

      Basic Library

      - -
        -
      • 2D Apollonius Graph (new package)
        -Algorithms for computing the Apollonius - graph in two dimensions. The Apollonius graph is the dual of the - Apollonius diagram, also known as the additively weighted Voronoi - diagram. The latter can be thought of as the Voronoi diagram of a set - of circles under the Euclidean metric, and it is a generalization of the - standard Voronoi diagram for points. The algorithms provided are - dynamic. - -
      • dD Min Sphere of Spheres (new package)
        - Algorithms to compute the smallest - enclosing sphere of a given set of spheres in Rd. - The package provides - an algorithm with maximal expected running time - O(2O(d) n) and a - fast and robust heuristic (for dimension less than 30). - -
      • Spatial Searching (new package)
        -Provides exact and approximate distance - browsing in a set of points in d-dimensional space using - implementations of algorithms supporting: -
          -
        • both nearest and furthest neighbor searching -
        • both exact and approximate searching -
        • (approximate) range searching -
        • (approximate) k-nearest and k-furthest neighbor - searching -
        • (approximate) incremental nearest and incremental furthest neighbor - searching -
        • query items representing points and spatial objects. -
        - -
      • Kd-tree
        -this package is deprecated, its documentation is removed. - It is replaced by the Spatial Searching package. - -
      • Largest_empty_rectangle_2
        - Given a set of points P in the plane, the class - Largest_empty_iso_rectangle_2 is a data structure that - maintains an iso-rectangle with the largest area among all - iso-rectangles that are inside a given iso-rectangle bounding box, - and that do not contain any point of the point set P. - -
      • 2D Triangulation and - 3D Triangulation
        -
          -
        • The classes Triangulation_data_structure_2 (and 3), which implements - the data structure for 2D triangulation class, now makes use of - CGAL::Compact_container (see Support Library section below). -
        • The triangulation classes use a Rebind mecanism to provide - the full flexibility on Vertex and Face base classes. - This means that it is possible for the user to derive its own Face - of Vertex base class, adding a functionality that makes use of - types defined by the triangulation data structure like Face_handle - or Vertex_handle. -
        • New classes Triangulation_vertex_base_with_info_2 (and 3) and - Triangulation_face_base_with_info_2 (and 3) to make easier the - customisation of base classes in most cases. -
        - -
      • 2D Triangulation
        -
          -
        • Regular triangulation provides an easy access to hidden points. -
        • The Triangulation_hierarchy_2, which provide an efficient location - data structure, can now be used with any 2D triangulation class plugged - in (including Regular triangulations). -
        - -
      • 3D Triangulation
        -
          -
        • faster vertex removal function in Delaunay_triangulation_3. -
        • Delaunay_triangulation_3 is now independent of the order of insertions - of the points (in case of degenerate cosphericity). -
        • Regular_triangulation_3 now hides vertices (and updates itself) when - inserting a coinciding point with greater weight. This required a new - predicate. -
        • deprecated functions: copy_triangulation(), push_back(), - set_number_of_vertices(). -
        • Triangulation_3 now gives non-const access to the data structure. -
        - -
      • Interval Skip List (new package)
        -An interval skip list is a data strucure for finding all intervals - that contain a point, and for stabbing queries, that is for answering - the question whether a given point is contained in an interval or not. - -
      • - Planar Maps and - - Arrangements
        - - The changes concern mainly the traits classes. -
          -
        1. New traits hierarchy and interface: - The set of requirements was made sound and complete. A couple of - requirements were eliminated, few others were redefined, and some - were renamed. A hierarchy of three traits classes for the - Planar_map_2, Planar_map_with_intersections_2, and Arrangement_2 - types was established to include only the necessary requirements at - each level. It was determined that for the aggregate insertion- - operation based on a sweep-line algorithm only a subset of the - requirements is needed. Preconditions were added where appropriate - to tighten the requirements further. - -

          - The following functions have been renamed: -

            -
          • point_is_same() renamed to point_equal() -
          • curve_is_same() renamed to curve_equal() -
          • curve_is_in_x_range() renamed to point_in_x_range() -
          • curve_compare_at_x() renamed to curves_compare_y_at_x() - Furthermore, a precondition has been added that the reference - point is in the x-range of both curves. -
          • curve_compare_at_x_right() renamed to - curves_compare_y_at_x_to_right(). - Furthermore, a precondition has been added that both curves are - equal at the reference point and defined to its right. -
          • curve_compare_at_x_left() renamed to - curves_compare_y_at_x_to_left(). - Furthermore, a precondition has been added that both curves are - equal at the reference point and defined to its right. -
          • curve_get_point_status() renamed to curve_compare_y_at_x(). - Furthermore, a precondition has been added that the point is in - the x-range of the curve. Consequently, the function now returns a - Comparison_result (instead of a special enum). -
          • make_x_monotone() renamed to curve_make_x_monotone() - See more details below. -
          • curve_flip() renamed to curve_opposite() -
          - - The following functions have been removed: -
            -
          • curve_is_between_cw() -
          • point_to_left() -
          • point_to_right() -
          • is_x_monotone() -
          • point_reflect_in_x_and_y() -
          • curve_reflect_in_x_and_y() -
          • do_intersect_to_right() -
          • do_intersect_to_left() -
          - - Most functions, are required by the PlanarMapTraits_2 concept, - except for the make_x_monotone(), nearest_intersection_to_right(), - nearest_intersection_to_left(), curves_overlap() and - curve_opposite(). PlanarMapWithIntersectionsTraits_2 requires all - these functions, except curve_opposite(), needed only by the - ArrangementTraits_2 concept. -

          - Furthermore, the two functions curve_compare_at_x_left() and - nearest_intersection_to_left() can be omitted, if the two functions - point_reflect_in_x() and curve_reflect_in_x() are implemented. - Reflection can be avoided, if the two _left functions are supplied. - -

        2. The type X_curve_2 of the PlanarMapWithIntersectionsTraits_2 - concept was renamed to X_monotone_curve_2, and the distinction - between this type and the Curve_2 type was made firm. The method - is_x_monotone() of the PlanarMapWithIntersectionsTraits_2 concept - was removed. The related method curve_make_x_monotone() is now - called for each input curve of type Curve_2 when curves are inserted - into a Planar_map_with_intersections_2 to subdivide the input curve - into x-monotone sub-curves (and in case the curve is already - x-monotone, this function is responsible for casting it to an - x-monotone curve). - -
        3. New and improved traits classes: -
        4. Conic traits - Arr_conic_traits_2 - Support finite segments of ellipses, hyperbolas and parabolas, as - well as line segments. The traits require an exact real number- - type, such as leda_real or CORE::Expr. - -
        5. Segment cached traits - Arr_segment_cached_traits_2 - This class uses an improved representation for segments that helps - avoiding cascaded computations, thus achieving faster running - times. To work properly, an exact rational number-type should be - used. - -
        6. Polyline traits - Arr_polyline_traits_2 - The polyline traits class has been reimplemented to work in a more - efficient, generic manner. The new class replaces the obsolete - Arr_polyline_traits class. It is parameterized with a segment - traits class. - -
        7. Hyperbola and segment traits - Arr_hyper_segment_traits_2 - Supports line segments and segments of canonical hyperbolas. - This is the type of curves that arise when projecting segments - in three-space rotationally around a line onto a plane containing - the line. Such projections are often useful in CAD/CAM problems. - -
        8. Removed old traits class: -
            -
          • The models of the PlanarMapWithIntersectionsTraits_2 concept - below became obsolete, as the new conic traits, namely - Arr_conic_traits_2, supports the same functionality and is much - more efficient. -
              -
            • Arr_circles_real_traits -
            • Arr_segment_circle_traits -
            -
          • The segment traits class and the new polyline traits class were - reimplemented using standard CGAL-kernel calls. This essentially - eliminated the corresponding leda traits classes, namely: -
              -
            • Pm_leda_segment_traits_2 -
            • Arr_leda_segment_traits_2 -
            • Arr_leda_polyline_traits -
            - With the use of the Leda_rat_kernel new external package the same - functionality can be achieved with less overhead and more - efficiency. -
          - -
        9. Sweep Line
          -
            -
          • The Sweep_line_2 package was reimplemented. As a consequence it is much - more efficient, its traits is tighter (namely neither the two _left nor - the reflection functions are required), and its interface has changed a - bit. -
              -
            1. The following global functions have been removed: -
                -
              • sweep_to_produce_subcurves_2() -
              • sweep_to_produce_points_2() -
              • sweep_to_construct_planar_map_2() -
              - Instead, the public methods of the Sweep_line_2 class listed below - were introduced: -
                -
              • get_subcurves() - Given a container of curves, this function - returns a list of curves that are created by intersecting the - input curves. - -
              • get_intersection_points() - Given a range of curves, this function - returns a list of points that are the intersection points of the - curves. - -
              • get_intersecting_curves() - Given a range of curves, this function - returns an iterator to the beginning of a range that contains the - list of curves for each intersection point between any two curves - in the specified range. -
              -
            2. It is possible to construct a planar map with intersections (or an - arrangement) by inserting a range of curves into an empty map. This - will invoke the sweep-line process to construct the map more - efficiently. -
            -
          • New interface functions to the Planar_map_with_intersections_2 class. - The Planar_map_with_intersections_2 class maintains a planar map of - input curves that possibly intersect each other and are not necessarily - x-monotone. If an input curve, or a set of input curves, are known to - be x-monotone and pairwise disjoint, the new functions below can be - used to insert them into the map efficiently. -
          -
        -
      • Polyhedral Surface
        -
          -
        • The old design that was deprecated since CGAL 2.3 has been removed. -
        • Class Polyhedron_incremental_builder_3: -
            -
          • Renamed local enum ABSOLUTE to - ABSOLUTE_INDEXING, and RELATIVE to - RELATIVE_INDEXING to avoid conflicts with similarly - named macros of another library. -
          • Changed member functions add_vertex(), - begin_facet(), and end_facet() to return - useful handles. -
          • Added test_facet() to check facets for validity - before adding them. -
          • Added vertex( size_t i) to return Vertex_handle - for index i. -
          -
        - -
      • Halfedge Data Structure
        -
          -
        • The old design that was deprecated since CGAL 2.3 has been removed. -
        - -
      - -

      Support Library

      - -
        -
      • New container class Compact_container, which (roughly) provides the - flexibility of std::list, with the memory compactness of std::vector. - -
      • Geomview_stream: added a function - gv.draw_triangles(InputIterator begin, InputIterator end) - which draws a set of triangles much more quickly than one by one. - -
      • Number types: -
          -
        • number types are now required to provide a function: - std::pair<double, double> to_interval(const NT &). -
        • number types are now required to provide mixed operators with "int". -
        • CLN support removed. -
        • faster square() for MP_Float. -
        • added Gmp_q. -
        - -
      • Qt_widget: -
          -
        • New classes: -
            -
          • Qt_help_window: provides a simple way to show some helpful - information about a demo as an HTML page. -
          • Qt_widget_history: provides basic functionality to manipulate - intervals of Qt_widget class. The current visible area of Qt_widget - is mapped to an interval. Each interval could be stored in the - Qt_widget_history object. So you can use this object to navigate in - history. It is mostly used by Qt_widget_standard_toolbar. -
          -
        • Changes: -
            -
          • Qt_widget_standard_toolbar: is derived from QToolBar class, so pay - attention to modify your code, if you used this class. Some public - methods were introduced to control the history object that the - toolbar use to navigate. -
          • the icons are now part of libCGALQt. -
          -
        • Deprecated members of Qt_widget: -
            -
          • add_to_history(), clear_history(), back(), forth(): use forward(), - back() and clear_history() of the Qt_widget_standard_toolbar instead. -
          • custom_redraw(): use redraw_on_back() and redraw_on_front() instead. -
          -
        • Optimizations: - the output operators of the following classes have been optimized: -
            -
          • CGAL::Segment_2 (now tests for intersection with the drawing area) -
          • CGAL::Triangle_2 (now tests for intersection with the drawing area) -
          • CGAL::Triangulation_2 (is optimized for faster display on zooming) -
          -
        -
      - -

      Erratum in the Kernel manual

      - -
        -
      • Intersection test routines -

        The documentation of - CGAL::do_intersect - should mention, for the 3D case: -
        - Also, in three-dimensional space Type1 can be -

          -
        • either - Plane_3<Kernel> -
        • or Triangle_3<Kernel> -
        - and Type2 any of -
          -
        • Plane_3<Kernel> -
        • Line_3<Kernel> -
        • Ray_3<Kernel> -
        • Segment_3<Kernel> -
        • Triangle_3<Kernel> -
        - -

        - In the same way, for - Kernel::DoIntersect_3: -
        - for all pairs Type1 and Type2, where - the type Type1 is -

          -
        • either - Kernel::Plane_3 -
        • or Kernel::Triangle_3 -
        - - and Type2 can be any of the following: -
          -
        • Kernel::Plane_3 -
        • Kernel::Line_3 -
        • Kernel::Ray_3 -
        • Kernel::Segment_3 -
        • Kernel::Triangle_3 -
        - -

        - Philippe Guigue (INRIA Sophia-Antipolis) should be - mentioned as one of the authors. - -

      - -
      - -

      Release 2.4

      -
      -

      Release date: May 2002

      -

      Version 2.4 differs from version 2.3 in the platforms that are supported and -in functionality. There have also been a number of bug fixes for this release.

      - -

      -Additional supported platforms: -

        -
      • Microsoft Visual C++, version 7. -
      • SunPro 5.3 (with patch 111685-05) on Solaris -
      • g++ 3.1 on Linux and Solaris -
      - -

      -The following functionality has been added or changed:

      - -

      Kernels

      - -
        -
      • Point_d has been removed from the 2D and 3D kernels. This type is - now available from the d-dimensional kernel only. -
      - -

      Basic Library

      - -
        - -
      • 2D Polygon Partitioning
        - - Traits requirements for optimal partitioning have been changed slightly. -

        - -
      • 2D Sweep line
        - - A new package that implements a sweep-line algorithm to compute - arrangements of curves for different families of curves, which are - not necessarily line segments (e.g., it also works for circular arcs). - The resulting output can be the list of vertex points, the resulting - subcurves or a planar map. -

        - -
      • - Planar Maps and - - Arrangements - -
          -
        • New quicker insertion functions of Planar_map_2 for cases where more - precomputed information is available regarding the position of - the inserted curve in the map. - -
        • New query function for planar maps that determines whether a given - point is within a given face of the planar map. - -
        • New iterator over edges of planar maps in addition to the existing - iterator over halfedges. - -
        • New copy constructor and assignment operator for arrangements. -
        -

        - -
      • - Polyhedral Surface -
          -
        • new design introduced with release 2.3 now supported by VC7 compiler - -
        • Extended functionality of Polyhedron_incremental_builder: - absolute indexing allows one to add new surfaces to existing ones. -
        -

        - -
      • 2D Triangulation -
          -
        • There is a new triangulation data structure replacing the two - previous ones. This new data structure is coherent with the 3d - triangulation data structure and offer the advantages of both - previous ones. Backward compatibility is ensured and this change - is transparent for the user of triangulation classes. -
        • Constrained and Delaunay constrained triangulations are now able - to handle intersecting input constraints. - The behavior of constrained triangulations with repect to - intersection of input constraints can be customized using - an intersection tag. -
        • A new class Constrained_triangulation_plus offers a constrained - hierarchy on top of a constrained triangulations. This additionnal - data structure describes the subdivision of the original constraints - into edges of the triangulations. -
        -

        - - -
      • 3D Triangulation -
          -
        • Running time improved by a better and more compact management of - memory allocation - -
        • Various improvements and small functionalities added: -
            -
          • Triangulation_3<GT,Tds>::triangle() returns a triangle oriented - towards the outside of the cell c for facet (c,i) -
          • New function insert(Point, Locate_type, Cell_handle, int, int) - which avoids the location step. -
          • New function to get access to cells in conflict in a Delaunay - insertion : find_conflicts() and insert_in_hole() -
          • New function TDS::delete_cells(begin, end). -
          • New functions : degree(v), reorient(), remove_decrease_dimension(), - remove_from_simplex(). -
          - -
        • Changes of interface: -
            -
          • vertices and cells are the same for the triangulation data - structure and the geometric triangulation -
          • the triangulation data structure uses Vertex_handle (resp - Cell_handle) instead of Vertex* (resp Cell*). -
          • incident_cells() and incident_vertices() are templated by output - iterators -
          • changes in the iterators and circulators interface: -
              -
            • Iterators and circulators are convertible to handles - automatically, no need to call "->handle()" anymore. -
            • Vertex_iterator split into All_vertices_iterator and - Finite_vertices_iterator (and similar for cells...). -
            • TDS::Edge/Facet iterators now support operator->. -
            -
          -
        -

        -
      • 2D Search structures
        - Additional range search operations taking a predicate functor have been - added -
      - -

      Support Library

      -
        -
      • Qt_widget -
          -
        • We have added a new class for visualization of 2D CGAL objects. - It is derived from Trolltech's Qt class QWidget and privdes a - used to scale and pan. -
        • Some demos were developed for the following packages: 2D Alpha shapes, - 2D Convex Hull, Largest empty 2D rectangle, Maximum k-gon, - Minimum ellipse, Minimum 2D quadrilateral, 2D polygon partitioning - 2D regular and constrained triangulation. -
        • Tutorials are available to help users get used to Qt_widget -
        -

        - -
      • Timer
        - - Fixed Timer class (for user process time) to have no wrap-around - anymore on Posix-compliant systems. -
      - -

      -The following functionality is no longer supported: -

        -
      • Planar maps of infinite curves (the so-called planar map bounding-box). -
      - -

      -Bugs in the following packages have been fixed: - 3D Convex hull, 2D Polygon partition, simple polygon generator - -

      -Also attempts have been made to assure compatability with the upcoming LEDA -release that introduces the leda namespace. - -

      -

      Known problems

      -
        -
      • 2D Nef Polyhedra contains a memory leak. Memory problems are also - the likely cause of occasional run-time errors on some platforms. -
      • The d-dimensional convex hull computation produces run-time errors on - some platforms because of memory management bugs. -
      • The new Halfedge Data Structure design introduced with release 2.3 - does not work on VC6. See the release notes in the manual for more - information. -
      • The following deficiencies relate to planar maps, planar maps of - intersecting curves (pmwx), arrangements and sweep line. -
          -
        • On KCC, Borland and SunPro we guarantee neither compilation nor - correct execution for all of the packages above. -
        • On VC6 and VC7 we guarantee neither compilation nor correct - execution of the sweep line package. -
        • On CC (on Irix 6.5) the trapezoidal decomposition point location - strategy is problematic when used with planar maps, pmwx, or - arrangements (mind that this is the default for planar maps). -
        • On CC (on Irix 6.5) sweep line with polyline traits does not compile - (mind that the so-called leda polyline traits does compile). -
        • On g++ (on Irix 6.5) the segment-circle (Arr_segment_circle_traits_2) - traits does not compile for either of the above packages. -
        -
      - - -
      - - -

      Release 2.3

      -
      -

      Release date: August 2001

      - -

      Version 2.3 differs from version 2.2 in the platforms that are supported and -in functionality.

      - -

      -Additional supported platform: - -

        -
      • Gnu g++ 3.0 on Solaris and Linux -
      - -

      -The following functionality has been added:

      - -

      Kernels

      -
        -
      • The 2D and 3D kernels now serve as models of the new kernel concept - described in the recent paper, "An Adaptable and Extensible Geometry - Kernel" by Susan Hert, Micheal Hoffmann, Lutz Kettner, Sylvain Pion, - and Michael Seel to be presented at - WAE 2001 (and - soon available as a technical report). This new kernel is - completely compatible with the previous design but is more flexible - in that it allows geometric predicates as well as objects to be easily - exchanged and adapted individually to users' needs. - -
      • A new kernel called Simple_homogeneous is available. It is - equivalent to Homogeneous but without reference-counted objects. - -
      • A new kernel called Filtered_kernel is available that allows - one to build kernel traits classes that use exact and efficient predicates. - -
      • There are two classes, Cartesian_converter and - Homogeneous_converter - that allows one to convert objects between different Cartesian and - homogeneous kernels, respectively. - -
      • A new d-dimensional kernel, Kernel_d is available. It provides - diverse kernel objects, predicates and constructions in d dimensions with - two representations based on the kernel families Cartesean_d and - Homogeneous_d -
      - -

      Basic Library

      - Almost all packages in the basic library have been adapted to the - new kernel design to realize the flexibility this design makes possible. - In several packages, this means that the traits class requirements have - changed to conform to the function objects offered in the kernels so the - kernels themselves can be used as traits classes in many instances. - -
        -
      • - 2D Convex Hull
        - The traits requirements have changed slightly to bring them in line with - the CGAL kernels. - -
      • - 3D Convex Hull -
          -
        • The function convex_hull_3 now uses a new implementation of the - quickhull algorithm and no longer requires LEDA. -
        • A new convex_hull_incremental_3 function based on the new - d-dimensional convex hull class is available for comparison purposes. -

        - -
      • - Convex_hull_d, Delaunay_d
        - Two new application classes offering the calculation of d-dimensional - convex hulls and delaunay triangulations

        - -
      • - Polygons and Polygon Operations
        -
          -
        • The traits class requirements have been changed. -
        • The simplicity test has a completely new implementation. -
        • Properties like convexity, simplicity and area can now be cached by - polygons. You need to set a flag to select this behaviour. -
        -
        - -

        -
      • - Planar Nef Polyhedra
        - A new class (Nef_polyhedron_2) representing planar Nef polyhedra = - rectilinearly bounded points sets that are the result of binary and - topological operations starting from halfplanes. - -

        -
      • A new package offering functions to - - partition planar polygons into - convex and y-monotone pieces is available. - -

        -
      • - Planar Maps and - - Arrangements -
          -
        • A new class Planar_map_with_intersections_2<Planar_map> for - planar maps of possibly intersecting, possibly non-x-monotone, - possibly overlapping curves (like Arrangement_2 but without - the hierarchy tree). - -
        • I/O utilities for planar maps and arrangements for textual and - graphical streams. (It is possible to save and later reload built - planar maps or arrangements.) - -
        • New arrangement traits class for line segments and circular arcs - (Arr_segment_circle_traits<NT>). - -
        • New faster traits for polylines specialized for using the LEDA - rational kernel (Arr_leda_polylines_traits). The LEDA - traits for segments was also made faster. - -
        • A new point location strategy - (Pm_simple_point_location<Planar_map>). -
        -

        - -
      • - Halfedge Data Structure

        - - The halfedge data structure has been completely revised. The new design - is more in line with the STL naming scheme and it provides a safe and - coherent type system throughout the whole design (no void* pointers - anymore), which allows for better extendibility. A user can add new - incidences in the mesh easily. The new design also uses standard - allocators with a new template parameter that has a suitable default. -

        - - The old design is still available, but its use is deprecated, see the - manual of - deprecated packages for its documentation. Reported bugs in - copying the halfedge data structure (and therefore also polyhedral - surfaces) have been fixed in both designs. Copying a list-based - representation is now based on hash maps instead of std::map and is - therefore considerably faster. - -

        -
      • - Polyhedral Surface - -

        - The polyhedral surface has been rewritten to work with the new - halfedge data structure design. The user level interface of the - CGAL::Polyhedron_3 class is almost backwards compatible with the - previous class. The exceptions are the template parameter list, - everything that relies on the flexibility of the underlying - halfedge data structure, such as a self-written facet class, and - that the distinction between supported normals and supported planes - has been removed. Only planes are supported. See the manuals for - suggestions how to handle normals instead of planes. - -

        - More example programs are provided with polyhedral surfaces, - for example, one about Euler operator and one computing a subdivision - surface given a control mesh as input. - -

        - The old design is still available for backwards compatibility and to - support older compiler, such as MSVC++6.0. For the polyhedral surface, - old and new design cannot be used simultaneously (they have identical - include file names and class names). The include files select - automatically the old design for MSVC++6.0 and the new design - otherwise. This automatism can be overwritten by defining appropriate - macros before the include files. The old design is selected with the - CGAL_USE_POLYHEDRON_DESIGN_ONE macro. The new design is selected - with the CGAL_USE_POLYHEDRON_DESIGN_TWO macro. - -

        -
      • - 2D Triangulation -
          -
        • The geometric traits class requirements have been changed to conform - to the new CGAL kernels. CGAL kernel classes can be used as traits - classes for all 2D triangulations except for regular triangulations. - -
        • Additionnal functionality: -
            -
          • dual method for regular triangulations (to build a power diagram) -
          • unified names and signatures for various "find_conflicts()" - member functions in Delaunay and constrained Delaunay triangulation. -
          • As an alternative to the simple insert() member function, - insertion of points in those triangulation can be performed using the - combination of find_conflicts() and star_hole() which eventually - allows the user to keep track of deleted faces. -
          - -
        • More demos and examples -
        - -
        -
      • - 3D Triangulation -
          -
        • Major improvements -
            -
          • A new class Triangulation_hierarchy_3 that allows a - faster point location, and thus construction of the Delaunay - triangulation -
          • A new method for removing a vertex from a Delaunay - triangulation that solves all degenerate cases -
          • Running time of the usual location and insertion methods - improved -
          - -
        • A bit more functionality, such as -
            -
          • New geomview output -
          • dual methods in Delaunay triangulations to draw the Voronoi - diagram -
          -
        • More demos and examples - -
        • Changes in interface -
            -
          • Traits classes requirements have been modified -
          • The kernel can be used directly as a traits class (except for - regular triangulation) -
          • insert methods in Triangulation_data_structure have a - new interface -
          -
        -
        -
      • A new class (Alpha_shapes_3) that computes Alpha shapes of point - sets in 3D is available. - -

        -
      • The traits requirements for matrix search and - minimum quadrilaterals have been changed to bring them - in line with the CGAL kernels. -

        - -
      • Point_set_2 -
          -
        • now independent of LEDA; based on the CGAL Delaunay triangulation -
        • traits class requirements adapted to new kernel concept. -
        • function template versions of the provided query operations are - available -
        -
      - -

      Support Library

      -
        -
      • Number types: -
          -
        • Lazy_exact_nt<NT> is a new number type wrapper to speed - up exact number types. -
        • MP_Float is a new multiprecision floating point number - type. It can do exact additions, subtractions and multiplications - over floating point values. -
        - -
      • In_place_list has a new third template parameter - (with a suitable default) for an STL-compliant allocator. - -
      • - Unique_hash_map is a new support class. - -
      • - Union_find is a new support class. - -
      • - Geomview_stream : -
          -
        • Geomview version 1.8.1 is now required. -
        • no need to have a ~/.geomview file anymore. -
        • new output operators for triangulations. -
        • new output operators for Ray_2, Line_2, - Ray_3, Line_3, Sphere_3. -
        • various new manipulators. -
        - -
      • Window stream - In cooperation with Algorithmic Solutions, GmBH (distributors of - the LEDA library), we can now offer a visualization package - downloadable in binary form that supports visualization on a ported - version of the LEDA window lib. -
      - -
      - - -

      Release 2.2

      -
      -

      Release date: October 2000

      - -

      Version 2.2 differs from version 2.1 in the platforms that are supported and -in functionality.

      - -

      -Additional supported platforms: - -

        -
      • the KAI compiler (4.0) on Solaris 5.8 -
      • Borland C++ (5.5) -
      - -

      -The following functionality has been added: - -

        -
      • There is a new, non-reference-counted kernel, Simple_cartesian. Because - reference counting is not used, and thus coordinates are stored within a - class, debugging is easier using this kernel. This kernel can also be - faster in some cases than the reference-counted Cartesian kernel. - -
      • New optimisation algorithms -
          -
        • Min_annulus_d - Algorithm for computing the smallest enclosing - annulus of points in arbitrary dimension -
        • Polytope_distance_d - Algorithm for computing the (squared) - distance between two convex polytopes in arbitrary dimension -
        • Width_3 - Algorithm for computing the (squared) width of points - sets in three dimensions -
        - -
      • 2D Triangulations -
          -
        • There are now two triangulation data structures available in CGAL. - The new one uses a list to store the faces and allows one to - represent two-dimensional triangulations embedded in three spaces - as well as planar triangulations. -
        • The triangulation hierarchy which allows fast location query - is now available. -
        - -
      • Inifinite objects can now be included in planar maps. - -
      • Removal as well as insertions of vertices for 3D Delaunay triangulations - is now possible. - -
      • A generator for ``random'' simple polygons is now available. - -
      • In directory demo/Robustness, programs that demonstrate typical robustness - problems in geometric computing are presented along with the solutions to - these problems that CGAL provides. -
      - -

      -The following functionality has been removed: -

        -
      • The binary operations on polygons (union, intersection ...) have been - removed. Those operations were not documented in the previous release - (2.1). Arrangements can often be used as a substitute. -
      -
      - - -

      Release 2.1

      - -
      -

      Release date: January 2000

      - -

      Version 2.1 differs from version 2.0 in the platforms that are supported and -in functionality.

      - -

      -Supported platforms: - -

        -
      • the newest gnu compiler (2.95.2) on Sun, SGI, Linux and Windows. -
      • the Microsoft Visual C++ compiler, version 6. -
      • the mips CC compiler version 7.3 under Irix. -
      - -Support for the old g++ compiler (2.8) and for mips CC 7.2 has been dropped. - -

      -The following functionality has been added: - -
        -
      • Alpha shapes and weighted alpha shapes in 2D. Alpha shapes are a - generalization of the convex hull of a point set. -
      • Arrangements in 2D. Arrangements are related to and based on planar maps. - The major difference between the two is that curves are allowed to - intersect in the case of arrangements. -
      • Extensions to triangulations in 2D. Constrained triangulations are now - dynamic: they support insertions of new constraint as well as removal of - existing constraints. There are also constrained Delaunay triangulations. -
      • Triangulations in 3D were added, both Delaunay triangulations and regular - triangulations. -
      • Min_quadrilateral optimisations have been added. These are algorithms to - compute the minimum enclosing rectangle/parallelogram (arbitrary - orientation) and the minimum enclosing strip of a convex point set. -
      • 2d Point_set is a package for 2d range search operations, Delaunay - triangulation, nearest neighbor queries. This package works only if - LEDA - is installed. -
      • Support for GeoWin visualization library. This also depends on - LEDA. -
      • Support for using the - CLN number type - together with CGAL. -
        • -
      -
      - - -

      Release 2.0

      -
      -

      Release date: June 1999

      - -

      The main difference from release 1.2 is the -introduction of namespaces -- namespace std for code from -the standard library and namespace CGAL for -the CGAL library. -

      - - -

      Release 1.2

      -
      -

      Release date: January 1999

      -

      Additions to release 1.1 include:

      - -
        -
      • topological map -
      • planar map overlay -
      • regular and constrained triangulations -
      -
      - - -

      Release 1.1

      -
      -

      Release date: July 1998

      - -

      Additions to release 1.0 include: -

        -
      • 3D intersections
        • -
      • kD points
        • -
      • 3D convex hull
        • -
      • kD smallest enclosing sphere
        • -
      -
      - - - -

      Release 1.0

      -
      -

      Release date: April 1998

      - -

      Additions to release 0.9 include: -

        -
      • Polyhedral surfaces
        • -
      • Halfedge Data Structure
        • -
      • Planar maps
        • -
      -
      - - -

      Release 0.9

      -
      -

      Release date: June 1997

      -

      Initial (beta) release of the CGAL library. -

      - - -
      - - diff --git a/Installation/changes.md b/Installation/changes.md index 79a4a66ba6a..0ec56872cf7 100644 --- a/Installation/changes.md +++ b/Installation/changes.md @@ -69,6 +69,10 @@ Release date: April 2018 ### 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 new functions for feature detection and feature-guided segmentation: - `CGAL::Polygon_mesh_processing::detect_sharp_edges()` From 93c7018ab0e9a7d9b5d2db9092076016d7fdeca2 Mon Sep 17 00:00:00 2001 From: Maxime Gimeno Date: Mon, 27 Nov 2017 10:33:07 +0100 Subject: [PATCH 13/23] Update doc --- .../Polygon_mesh_processing/PackageDescription.txt | 2 ++ .../Polygon_mesh_processing.txt | 10 ++++++++++ .../CGAL/Polygon_mesh_processing/orientation.h | 14 +++++--------- 3 files changed, 17 insertions(+), 9 deletions(-) diff --git a/Polygon_mesh_processing/doc/Polygon_mesh_processing/PackageDescription.txt b/Polygon_mesh_processing/doc/Polygon_mesh_processing/PackageDescription.txt index 6be846bc625..1e5f630e4a6 100644 --- a/Polygon_mesh_processing/doc/Polygon_mesh_processing/PackageDescription.txt +++ b/Polygon_mesh_processing/doc/Polygon_mesh_processing/PackageDescription.txt @@ -109,6 +109,8 @@ and provides a list of the parameters that are used in this package. - `CGAL::Polygon_mesh_processing::is_outward_oriented()` - `CGAL::Polygon_mesh_processing::reverse_face_orientations()` - `CGAL::Polygon_mesh_processing::orient_polygon_soup()` +- `CGAL::Polygon_mesh_processing::orient()` +- `CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()` ## Combinatorial Repairing Functions ## - \link PMP_repairing_grp `CGAL::Polygon_mesh_processing::stitch_borders()` \endlink diff --git a/Polygon_mesh_processing/doc/Polygon_mesh_processing/Polygon_mesh_processing.txt b/Polygon_mesh_processing/doc/Polygon_mesh_processing/Polygon_mesh_processing.txt index 24b67d7a036..6a0c72ca458 100644 --- a/Polygon_mesh_processing/doc/Polygon_mesh_processing/Polygon_mesh_processing.txt +++ b/Polygon_mesh_processing/doc/Polygon_mesh_processing/Polygon_mesh_processing.txt @@ -428,6 +428,16 @@ As a consequence, the normal computed for each face (see Section The \ref PolygonSoupExample puts these functions at work on a polygon soup. +The function +`CGAL::Polygon_mesh_processing::orient()` orients consistently the connected components +of a closed polygon mesh. All faces will then be oriented outward or inward, according +to the user's choice. + +The function +`CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()` orients the connected components +of a closed polygon mesh so that it bounds a volume. +See \ref coref_def_subsec for details. + **************************************** \section PMPRepairing Combinatorial Repairing diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 0eb2a055366..aac71a4f61a 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -454,12 +454,8 @@ namespace Polygon_mesh_processing { * @tparam NamedParameters a sequence of \ref namedparameters * * @param tm a closed triangulated `TriangleMesh` -* @param orient_positively indicates if the output mesh should be oriented positively (`true`) or negatively (`false`). +* @param orient_outward indicates if the output mesh should be oriented outward (`true`) or inward (`false`). * default value is true. -* A closed polygon mesh is considered to have a positive orientation if the normal vectors -* to all its faces point outside the domain bounded by the polygon mesh. -* The normal vector to each face is chosen pointing on the side of the face -* where its sequence of vertices is seen counterclockwise. * @param np optional sequence of \ref namedparameters among the ones listed below * * \cgalNamedParamsBegin @@ -474,7 +470,7 @@ namespace Polygon_mesh_processing { * \cgalNamedParamsEnd */ template -void orient(TriangleMesh& tm, bool orient_positively, const NamedParameters& np) +void orient(TriangleMesh& tm, bool orient_outward, const NamedParameters& np) { typedef boost::graph_traits Graph_traits; typedef typename Graph_traits::vertex_descriptor vertex_descriptor; @@ -529,7 +525,7 @@ void orient(TriangleMesh& tm, bool orient_positively, const NamedParameters& np) for(std::size_t id=0; id -void orient(TriangleMesh& tm, bool orient_positively) +void orient(TriangleMesh& tm, bool orient_outward) { - orient(tm, orient_positively, parameters::all_default()); + orient(tm, orient_outward, parameters::all_default()); } template From a639cdc7c61f009a4378149ec322f2ab75a307e5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 13 Dec 2017 09:28:02 +0100 Subject: [PATCH 14/23] add missing backticks --- Installation/changes.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Installation/changes.md b/Installation/changes.md index 0ec56872cf7..0449302d811 100644 --- a/Installation/changes.md +++ b/Installation/changes.md @@ -70,8 +70,8 @@ Release date: April 2018 ### Polygon Mesh Processing - Added two functions for orienting connected components : - - CGAL::Polygon_mesh_processing::orient() - - CGAL::Polygon_mesh_processing::orient_to_bound_a_volume() + - `CGAL::Polygon_mesh_processing::orient()` + - `CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()` - Added new functions for feature detection and feature-guided segmentation: From bca397c4ff4371a4ec0899b9bbe5c2da49bc4fe0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 13 Dec 2017 09:44:40 +0100 Subject: [PATCH 15/23] update user manual --- .../Polygon_mesh_processing.txt | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/Polygon_mesh_processing/doc/Polygon_mesh_processing/Polygon_mesh_processing.txt b/Polygon_mesh_processing/doc/Polygon_mesh_processing/Polygon_mesh_processing.txt index 6a0c72ca458..d2ffce815db 100644 --- a/Polygon_mesh_processing/doc/Polygon_mesh_processing/Polygon_mesh_processing.txt +++ b/Polygon_mesh_processing/doc/Polygon_mesh_processing/Polygon_mesh_processing.txt @@ -428,15 +428,12 @@ As a consequence, the normal computed for each face (see Section The \ref PolygonSoupExample puts these functions at work on a polygon soup. -The function -`CGAL::Polygon_mesh_processing::orient()` orients consistently the connected components -of a closed polygon mesh. All faces will then be oriented outward or inward, according -to the user's choice. +The function `CGAL::Polygon_mesh_processing::orient()` makes each connected component +of a closed polygon mesh outward or inward oriented. -The function -`CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()` orients the connected components -of a closed polygon mesh so that it bounds a volume. -See \ref coref_def_subsec for details. +The function `CGAL::Polygon_mesh_processing::orient_to_bound_a_volume()` orients +the connected components of a closed polygon mesh so that it bounds a volume +(see \ref coref_def_subsec for the precise definition). **************************************** From 3f45d98501d3d1f348b20f161979ee2b07f97e52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 13 Dec 2017 09:45:40 +0100 Subject: [PATCH 16/23] remove useless tests since the mesh must be closed --- .../Polygon_mesh_processing/orientation.h | 24 +++---------------- 1 file changed, 3 insertions(+), 21 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index aac71a4f61a..a0bd0795b17 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -25,6 +25,7 @@ #include + #include #include #include @@ -32,8 +33,6 @@ #include #include #include -#include -#include #include #include @@ -117,21 +116,7 @@ namespace internal{ Orientation p1p2p3_2d = orientation_2(p1, p2, p3); Orientation p2p1p4_2d = orientation_2(p2, p1, p4); - if(!( p1p2p3_2d!=COLLINEAR || p2p1p4_2d!=COLLINEAR )) - { - Projection_traits_xz_3 p_gt_bis; - typename Projection_traits_xz_3::Orientation_2 orientation_2_bis = p_gt_bis.orientation_2_object(); - p1p2p3_2d = orientation_2_bis(p1, p2, p3); - p2p1p4_2d = orientation_2_bis(p2, p1, p4); - if(!( p1p2p3_2d!=COLLINEAR || p2p1p4_2d!=COLLINEAR )) - { - Projection_traits_yz_3 p_gt_last; - typename Projection_traits_yz_3::Orientation_2 orientation_2_last = p_gt_last.orientation_2_object(); - p1p2p3_2d = orientation_2_last(p1, p2, p3); - p2p1p4_2d = orientation_2_last(p2, p1, p4); - } - } - CGAL_assertion( p1p2p3_2d!=COLLINEAR || p2p1p4_2d!=COLLINEAR );//no self-intersection + CGAL_assertion( p1p2p3_2d!=COLLINEAR || p2p1p4_2d!=COLLINEAR ); // no self-intersection if ( p1p2p3_2d == COLLINEAR) return p2p1p4_2d == LEFT_TURN; @@ -154,8 +139,6 @@ namespace internal{ CGAL_assertion(p2p1p4_2d == LEFT_TURN); return orientation_3(p2, p1, p4, p3) == NEGATIVE; } - - } // end of namespace internal /** @@ -353,7 +336,6 @@ void reverse_face_orientations(const FaceRange& face_range, PolygonMesh& pmesh) } } } -}//end PMP namespace internal { template @@ -443,8 +425,8 @@ void recursive_orient_volume_ccs( TriangleMesh& tm, tm, vpm, fid_map, xtrm_vertices, cc_handled, face_cc, new_xtrm_cc_id, is_parent_outward_oriented); } + }//end internal -namespace Polygon_mesh_processing { /** * \ingroup PMP_orientation_grp From d3e0fc820f8bb9594627884214d7fd44abeb0acb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 13 Dec 2017 09:45:59 +0100 Subject: [PATCH 17/23] update doc of orient() + turn checks into assertions --- .../CGAL/Polygon_mesh_processing/orientation.h | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index a0bd0795b17..a8617c99070 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -430,14 +430,17 @@ void recursive_orient_volume_ccs( TriangleMesh& tm, /** * \ingroup PMP_orientation_grp -* makes the orientation of all the connected components of a `TriangleMesh` consistent. +* makes each connected component of a closed triangulated surface mesh +* inward or outward oriented. * * @tparam TriangleMesh a model of `FaceListGraph` and `MutableFaceGraph` . +* If `TriangleMesh` has an internal property map for `CGAL::face_index_t`, +* as a named parameter, then it must be initialized. * @tparam NamedParameters a sequence of \ref namedparameters * -* @param tm a closed triangulated `TriangleMesh` -* @param orient_outward indicates if the output mesh should be oriented outward (`true`) or inward (`false`). -* default value is true. +* @param tm a closed triangulated surface mesh +* @param orient_outward `true` indicates that each connected component will be outward oriented, +* and inward oriented if `false`. Default value is true. * @param np optional sequence of \ref namedparameters among the ones listed below * * \cgalNamedParamsBegin @@ -463,9 +466,10 @@ void orient(TriangleMesh& tm, bool orient_outward, const NamedParameters& np) typedef typename GetFaceIndexMap::const_type Fid_map; - if (!is_triangle_mesh(tm)) return ; - if (!is_valid(tm)) return ; - if (!is_closed(tm)) return; + CGAL_assertion(is_triangle_mesh(tm)); + CGAL_assertion(is_valid(tm)); + CGAL_assertion(is_closed(tm)); + Vpm vpm = boost::choose_param(get_param(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); From f9b61facd7c2960e7de8f0a27b358cdc012d7568 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 13 Dec 2017 09:51:04 +0100 Subject: [PATCH 18/23] update doc of does_bound_a_volume() + add default for bool parameter --- .../CGAL/Polygon_mesh_processing/orientation.h | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index a8617c99070..7b9877b324a 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -440,7 +440,7 @@ void recursive_orient_volume_ccs( TriangleMesh& tm, * * @param tm a closed triangulated surface mesh * @param orient_outward `true` indicates that each connected component will be outward oriented, -* and inward oriented if `false`. Default value is true. +* (inward oriented if `false`). Default value is true. * @param np optional sequence of \ref namedparameters among the ones listed below * * \cgalNamedParamsBegin @@ -542,9 +542,9 @@ void orient(TriangleMesh& tm) * @tparam NamedParameters a sequence of \ref namedparameters * * @param tm a closed triangulated surface mesh - * @param orient_outward decides if the outer components should be oriented outward or - * inward. In this specific case, inwards means that the infinity will be considered - * as inside the volume bounded by `tm`. + * @param orient_outward if `true` the outer connected components will be outward oriented (inward oriented if `false`). + * If the outer connected components are inward oriented, it means that the infinity will be considered + * as part of the volume bounded by `tm`. Default value is `true`. * @param np optional sequence of \ref namedparameters among the ones listed below * * \cgalNamedParamsBegin @@ -636,6 +636,12 @@ void orient_to_bound_a_volume(TriangleMesh& tm, const bool orient_outward) { orient_to_bound_a_volume(tm, orient_outward, parameters::all_default()); } + +template +void orient_to_bound_a_volume(TriangleMesh& tm) +{ + orient_to_bound_a_volume(tm, true, parameters::all_default()); +} } // namespace Polygon_mesh_processing } // namespace CGAL #endif // CGAL_ORIENT_POLYGON_MESH_H From 4c2964ba6923269e11e6b3db2b9ce3a04d00b55f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 13 Dec 2017 09:56:40 +0100 Subject: [PATCH 19/23] fix namespace change --- .../include/CGAL/Polygon_mesh_processing/orientation.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 7b9877b324a..b3956a30469 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -359,7 +359,7 @@ void recursive_orient_volume_ccs( TriangleMesh& tm, } // first check that the orientation of the current cc is consistant with its // parent cc containing it - bool new_is_parent_outward_oriented = Polygon_mesh_processing::internal::is_outward_oriented( + bool new_is_parent_outward_oriented = internal::is_outward_oriented( xtrm_vertices[xtrm_cc_id], tm, parameters::vertex_point_map(vpm)); if (new_is_parent_outward_oriented==is_parent_outward_oriented) { @@ -623,7 +623,7 @@ void orient_to_bound_a_volume(TriangleMesh& tm, bool is_parent_outward_oriented = ! orient_outward; - CGAL::internal::recursive_orient_volume_ccs(tm, vpm, fid_map, + internal::recursive_orient_volume_ccs(tm, vpm, fid_map, xtrm_vertices, cc_handled, face_cc, From 82f931f5562900598503beb49ad8101b82fee1f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Wed, 13 Dec 2017 10:08:11 +0100 Subject: [PATCH 20/23] be more verbose in case of error --- .../Polygon_mesh_processing/test_orient_cc.cpp | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index 3cb4bdf0858..96960058232 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -74,11 +74,7 @@ bool test_orientation(TriangleMesh& tm, bool is_positive, const NamedParameters& int main() { -<<<<<<< HEAD std::ifstream input("data-coref/nested_cubes_invalid_volume.off"); -======= - std::ifstream input("data/Volume_nested_spheres.off"); ->>>>>>> 5bf8e4d86b... Add requirement close for orient function assert(input); SMesh sm1, sm2, sm3, sm4, volume; input >> sm1; @@ -98,11 +94,17 @@ int main() .face_index_map(fidmap2)); if(!test_orientation(sm2, true, PMP::parameters::vertex_point_map(vpmap2) .face_index_map(fidmap2))) + { + std::cerr << "ERROR for test1\n"; return 1; + } PMP::orient(sm3, false); if(!test_orientation(sm3, false, PMP::parameters::all_default())) + { + std::cerr << "ERROR for test2\n"; return 1; + } Ppmap vpmap4 = get(CGAL::vertex_point, sm4); Fidmap fidmap4 = get(CGAL::face_index, sm4); @@ -111,13 +113,17 @@ int main() .face_index_map(fidmap4)); if(!test_orientation(sm4, false, PMP::parameters::vertex_point_map(vpmap4) .face_index_map(fidmap4))) + { + std::cerr << "ERROR for test3\n"; return 1; - - + } PMP::orient_to_bound_a_volume(volume, true); if( !PMP::does_bound_a_volume(volume)) + { + std::cerr << "ERROR for test4\n"; return 1; + } return 0; } From 0d8f33f67d2b240f3bf55ad0cc30ec2badddb447 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Thu, 14 Dec 2017 10:38:11 +0100 Subject: [PATCH 21/23] remove duplicated typedef --- .../include/CGAL/Polygon_mesh_processing/orientation.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index b3956a30469..51c2151dfd8 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -573,8 +573,6 @@ void orient_to_bound_a_volume(TriangleMesh& tm, NamedParameters>::const_type Fid_map; typedef typename Kernel_traits< typename boost::property_traits::value_type >::Kernel Kernel; - typedef typename Kernel_traits< - typename boost::property_traits::value_type >::Kernel Kernel; if (!is_closed(tm)) return; if (!is_triangle_mesh(tm)) return; From a49f50c8aa9138a23e3940ca02ce835ca3e91f93 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Thu, 14 Dec 2017 10:41:47 +0100 Subject: [PATCH 22/23] add missing using directives --- .../Polygon_mesh_processing/orientation.h | 24 ++++++++++++------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 51c2151dfd8..2790183a122 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -255,7 +255,7 @@ void reverse_face_orientations(PolygonMesh& pmesh) typedef typename boost::graph_traits::halfedge_descriptor halfedge_descriptor; BOOST_FOREACH(face_descriptor fd, faces(pmesh)){ reverse_orientation(halfedge(fd,pmesh),pmesh); - } + } // Note: A border edge is now parallel to its opposite edge. // We scan all border edges for this property. If it holds, we // reorient the associated hole and search again until no border @@ -470,11 +470,14 @@ void orient(TriangleMesh& tm, bool orient_outward, const NamedParameters& np) CGAL_assertion(is_valid(tm)); CGAL_assertion(is_closed(tm)); - Vpm vpm = boost::choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(boost::vertex_point, tm)); + using boost::choose_param; + using boost::get_param; - Fid_map fid_map = boost::choose_param(get_param(np, internal_np::face_index), - get_const_property_map(boost::face_index, tm)); + Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + get_const_property_map(boost::vertex_point, tm)); + + Fid_map fid_map = choose_param(get_param(np, internal_np::face_index), + get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); @@ -576,11 +579,14 @@ void orient_to_bound_a_volume(TriangleMesh& tm, if (!is_closed(tm)) return; if (!is_triangle_mesh(tm)) return; - Vpm vpm = boost::choose_param(get_param(np, internal_np::vertex_point), - get_const_property_map(boost::vertex_point, tm)); + using boost::choose_param; + using boost::get_param; - Fid_map fid_map = boost::choose_param(get_param(np, internal_np::face_index), - get_const_property_map(boost::face_index, tm)); + Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), + get_const_property_map(boost::vertex_point, tm)); + + Fid_map fid_map = choose_param(get_param(np, internal_np::face_index), + get_const_property_map(boost::face_index, tm)); std::vector face_cc(num_faces(tm), std::size_t(-1)); From 4b1430ca075b1c578c8fa42588a69668bb9af199 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Loriot?= Date: Thu, 14 Dec 2017 11:23:43 +0100 Subject: [PATCH 23/23] use a named parameter for choosing inward or outward orientation --- .../NamedParameters.txt | 8 ++++ .../internal/parameters_interface.h | 1 + .../Polygon_mesh_processing/orientation.h | 39 +++++++++---------- .../test_orient_cc.cpp | 11 +++--- 4 files changed, 33 insertions(+), 26 deletions(-) diff --git a/Polygon_mesh_processing/doc/Polygon_mesh_processing/NamedParameters.txt b/Polygon_mesh_processing/doc/Polygon_mesh_processing/NamedParameters.txt index 87fbcb01bbf..34c82a38262 100644 --- a/Polygon_mesh_processing/doc/Polygon_mesh_processing/NamedParameters.txt +++ b/Polygon_mesh_processing/doc/Polygon_mesh_processing/NamedParameters.txt @@ -367,6 +367,14 @@ and perturbation is not deterministic \b Default is that this variable is not set \cgalNPEnd + +\cgalNPBegin{outward_orientation} \anchor PMP_outward_orientation +Parameter used in orientation functions to choose between an outward or inward orientation. +\n +\b Type : `bool` \n +\b Default value is `true` +\cgalNPEnd + \cgalNPTableEnd */ diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/parameters_interface.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/parameters_interface.h index 9247d934a7f..b2eab3f0341 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/parameters_interface.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/internal/parameters_interface.h @@ -45,6 +45,7 @@ CGAL_add_named_parameter(number_of_points_per_edge_t, number_of_points_per_edge, CGAL_add_named_parameter(number_of_points_on_edges_t, number_of_points_on_edges, number_of_points_on_edges) CGAL_add_named_parameter(nb_points_per_area_unit_t, nb_points_per_area_unit, number_of_points_per_area_unit) CGAL_add_named_parameter(nb_points_per_distance_unit_t, nb_points_per_distance_unit, number_of_points_per_distance_unit) +CGAL_add_named_parameter(outward_orientation_t, outward_orientation, outward_orientation) //to be documented CGAL_add_named_parameter(face_normal_t, face_normal, face_normal_map) diff --git a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h index 2790183a122..d7837064164 100644 --- a/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h +++ b/Polygon_mesh_processing/include/CGAL/Polygon_mesh_processing/orientation.h @@ -439,8 +439,6 @@ void recursive_orient_volume_ccs( TriangleMesh& tm, * @tparam NamedParameters a sequence of \ref namedparameters * * @param tm a closed triangulated surface mesh -* @param orient_outward `true` indicates that each connected component will be outward oriented, -* (inward oriented if `false`). Default value is true. * @param np optional sequence of \ref namedparameters among the ones listed below * * \cgalNamedParamsBegin @@ -452,10 +450,14 @@ void recursive_orient_volume_ccs( TriangleMesh& tm, * \cgalParamBegin{face_index_map} * a property map containing the index of each face of `tm`. * \cgalParamEnd +* \cgalParamBegin{outward_orientation} +* if set to `true` (default) indicates that each connected component will be outward oriented, +* (inward oriented if `false`). +* \cgalParamEnd * \cgalNamedParamsEnd */ template -void orient(TriangleMesh& tm, bool orient_outward, const NamedParameters& np) +void orient(TriangleMesh& tm, const NamedParameters& np) { typedef boost::graph_traits Graph_traits; typedef typename Graph_traits::vertex_descriptor vertex_descriptor; @@ -473,6 +475,9 @@ void orient(TriangleMesh& tm, bool orient_outward, const NamedParameters& np) using boost::choose_param; using boost::get_param; + bool orient_outward = choose_param( + get_param(np, internal_np::outward_orientation),true); + Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); @@ -521,16 +526,10 @@ void orient(TriangleMesh& tm, bool orient_outward, const NamedParameters& np) } } -template -void orient(TriangleMesh& tm, bool orient_outward) -{ - orient(tm, orient_outward, parameters::all_default()); -} - template void orient(TriangleMesh& tm) { - orient(tm, true, parameters::all_default()); + orient(tm, parameters::all_default()); } @@ -545,9 +544,6 @@ void orient(TriangleMesh& tm) * @tparam NamedParameters a sequence of \ref namedparameters * * @param tm a closed triangulated surface mesh - * @param orient_outward if `true` the outer connected components will be outward oriented (inward oriented if `false`). - * If the outer connected components are inward oriented, it means that the infinity will be considered - * as part of the volume bounded by `tm`. Default value is `true`. * @param np optional sequence of \ref namedparameters among the ones listed below * * \cgalNamedParamsBegin @@ -559,13 +555,17 @@ void orient(TriangleMesh& tm) * \cgalParamBegin{face_index_map} * a property map containing the index of each face of `tm`. * \cgalParamEnd + * \cgalParamBegin{outward_orientation} + * if set to `true` (default) the outer connected components will be outward oriented (inward oriented if set to `false`). + * If the outer connected components are inward oriented, it means that the infinity will be considered + * as part of the volume bounded by `tm`. + * \cgalParamEnd * \cgalNamedParamsEnd * * \see `CGAL::Polygon_mesh_processing::does_bound_a_volume()` */ template void orient_to_bound_a_volume(TriangleMesh& tm, - const bool orient_outward, const NamedParameters& np) { typedef boost::graph_traits Graph_traits; @@ -582,6 +582,9 @@ void orient_to_bound_a_volume(TriangleMesh& tm, using boost::choose_param; using boost::get_param; + bool orient_outward = choose_param( + get_param(np, internal_np::outward_orientation),true); + Vpm vpm = choose_param(get_param(np, internal_np::vertex_point), get_const_property_map(boost::vertex_point, tm)); @@ -635,16 +638,10 @@ void orient_to_bound_a_volume(TriangleMesh& tm, is_parent_outward_oriented); } -template -void orient_to_bound_a_volume(TriangleMesh& tm, const bool orient_outward) -{ - orient_to_bound_a_volume(tm, orient_outward, parameters::all_default()); -} - template void orient_to_bound_a_volume(TriangleMesh& tm) { - orient_to_bound_a_volume(tm, true, parameters::all_default()); + orient_to_bound_a_volume(tm, parameters::all_default()); } } // namespace Polygon_mesh_processing } // namespace CGAL diff --git a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp index 96960058232..bc52731eeb6 100644 --- a/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp +++ b/Polygon_mesh_processing/test/Polygon_mesh_processing/test_orient_cc.cpp @@ -90,7 +90,7 @@ int main() Ppmap vpmap2 = get(CGAL::vertex_point, sm2); Fidmap fidmap2 = get(CGAL::face_index, sm2); - PMP::orient(sm2, true, PMP::parameters::vertex_point_map(vpmap2) + PMP::orient(sm2, PMP::parameters::vertex_point_map(vpmap2) .face_index_map(fidmap2)); if(!test_orientation(sm2, true, PMP::parameters::vertex_point_map(vpmap2) .face_index_map(fidmap2))) @@ -99,7 +99,7 @@ int main() return 1; } - PMP::orient(sm3, false); + PMP::orient(sm3, PMP::parameters::outward_orientation(false)); if(!test_orientation(sm3, false, PMP::parameters::all_default())) { std::cerr << "ERROR for test2\n"; @@ -109,8 +109,9 @@ int main() Ppmap vpmap4 = get(CGAL::vertex_point, sm4); Fidmap fidmap4 = get(CGAL::face_index, sm4); - PMP::orient(sm4, false, PMP::parameters::vertex_point_map(vpmap4) - .face_index_map(fidmap4)); + PMP::orient(sm4, PMP::parameters::vertex_point_map(vpmap4) + .face_index_map(fidmap4) + .outward_orientation(false)); if(!test_orientation(sm4, false, PMP::parameters::vertex_point_map(vpmap4) .face_index_map(fidmap4))) { @@ -118,7 +119,7 @@ int main() return 1; } - PMP::orient_to_bound_a_volume(volume, true); + PMP::orient_to_bound_a_volume(volume); if( !PMP::does_bound_a_volume(volume)) { std::cerr << "ERROR for test4\n";