Release History

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)




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 SetOperations
 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 pointlocation strategy.
2D Snap Rounding
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 nonremovable by adding
a namedparameter
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 reused,
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 iattributes and which are automatically called when
icells 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
 Bugfix 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
pseudocircles as well.
 Updated implementation of the vertex conflict predicate by a
faster version.
3D Mesh Generation
 Speedup
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 speedup 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 nonwatertight and even
nonmanifold.
 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
AABBtree
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 sharedmemory 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 2Darrangements 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 WalkAlongALine 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
 Bugfix: Add ccb() method in face type as documented.
3D Minkowski Sum of Polyhedra
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 pointlocation 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 AklToussaint 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 CGAL4.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 CGAL4.0:
2D Voronoi Diagram Adaptor (readded)
 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_3Triangle_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 xaxis.
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 Eigen3.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 CGAL3.x series was released under a combination of LGPLv2 (for
the foundations of CGAL), and QPL (for the highlevel 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 CGAL4.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 highlevel 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 PointSampled 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
ddimension 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 readonly threadsafe. As usual in CGAL,
this small overhead introduced for threadsafety 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
Spatial Searching
 The constcorrectness 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 readonly threadsafe. As usual in CGAL,
this small overhead introduced for threadsafety can be deactivated by defining CGAL_HAS_NO_THREADS .
 Bugfix 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 threadsafety issue in
Delaunay_triangulation_2 remove functions. As usual in CGAL,
the small overhead introduced for threadsafety 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 traitsclass 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 ddimensional kernel concept and models have been modified
to additionally provide two new functors
Less_coordinate_d and Point_dimension_d .
2D Arrangements
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 strictansi 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 1dimensional 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, alphashapes, 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 strictansi 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 CGAL3.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 CGAL3.7.
 With Microsoft Windows Visual C++ (VC9 and VC10), the optional
dependencies Gmp, Mpfr, Blas, Lapack, Taucs no longer use Booststyle
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 cocircular 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 CGAL3.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 blackbox implementations of
stateoftheart 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 fixedprecision floatingpoint 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 SetOperations
 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 Beziercurve 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 overlaytraits, 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 : semistatic floatingpoint 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 CGAL3.4 and CGAL3.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 CGAL3.5 is now
based on CGAL3.5.1).
 Fixes to the bibliographic references.
Windows installer
 The Windows installer of CGAL3.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, CGAL3.5 has been developed during 9 months from the release
CGAL3.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 SetOperations
 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 traitsclass 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 axisaligned 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 compiletime 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
 nary 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 geometrytraits
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
(deselect), updated the howto 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 SetOperations
 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 sweepline 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 traitsclass:
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 offfile. 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:
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 runtime 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 rayshooting query from all arrangement vertices.
 Fixed a memory leak in the sweepline code.
 Fixed a bug in computing the minor axis of nondegenerate 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
zerowidth passages.
 Added a nonconst 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 pointlocation 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 multithreaded dynamically
linked runtime (/MD). Before it was the singlethreaded 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 SetOperations (new package)
This package consists of the implementation of Boolean setoperations
on point sets bounded by weakly xmonotone curves in 2dimensional
Euclidean space. In particular, it contains the implementation of
regularized Boolean setoperations, 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
2dimensional 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 threedimensional 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 CatmullClark, Loop, DooSabin 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 onetoone 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 stateoftheart 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 axisaligned 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 linesweeping 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 multipleprecision floatingpoint computations with exact rounding.
 Added Boost 1.32.0 (only include files).
Installation
 new option disableshared to omit building libCGAL.so.
Manuals
 Merged all major manuals in one multipart manual, which provides
now crosslinks 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 cellcomplexes 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 nonmanifold 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 isooriented 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
arbitraryprecision arrangements of segments into a fixedprecision
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 halfthewidthofapixel away
from any nonincident 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 conicarc 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 planarmap with arbitrary additional data was introduced. It should be instantiated with a regular traitsclass and a class that contains all extraneous data associated with a curve.
 The class that represents the trapezoidaldecomposition 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 sweepline 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 alphavalues. 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 selfintersection 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 bugfix release.
No new features have been added in 3.0.1. Here is the list of bugfixes.
Polyhedral Surface
 Fixed wrong include files for output support. Added example.
Planar_map
 Fixed the so called "Walkalongaline" pointlocation 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 1e5). 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 R^{d}.
The package provides
an algorithm with maximal expected running time
O(2^{O(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 ddimensional space using
implementations of algorithms supporting:
 both nearest and furthest neighbor searching
 both exact and approximate searching
 (approximate) range searching
 (approximate) knearest and kfurthest neighbor
searching
 (approximate) incremental nearest and incremental furthest neighbor
searching
 query items representing points and spatial objects.
 Kdtree
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 isorectangle with the largest area among all
isorectangles that are inside a given isorectangle 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 nonconst 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.
 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 sweepline 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 xrange 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 xrange 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.
 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 xmonotone subcurves (and in case the curve is already
xmonotone, this function is responsible for casting it to an
xmonotone curve).
 New and improved traits classes:
 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.
 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 numbertype should be
used.
 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.
 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 threespace rotationally around a line onto a plane containing
the line. Such projections are often useful in CAD/CAM problems.
 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 CGALkernel 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.
 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.
 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.
 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 sweepline 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
xmonotone. If an input curve, or a set of input curves, are known to
be xmonotone 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 threedimensional 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 SophiaAntipolis) 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 11168505) 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 ddimensional 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 sweepline 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 kgon,
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 wraparound
anymore on Posixcompliant systems.
The following functionality is no longer supported:
 Planar maps of infinite curves (the socalled planar map boundingbox).
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 runtime errors on some platforms.
 The ddimensional convex hull computation produces runtime 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 socalled leda polyline traits does compile).
 On g++ (on Irix 6.5) the segmentcircle (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 referencecounted 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 ddimensional 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
ddimensional convex hull class is available for comparison purposes.

Convex_hull_d, Delaunay_d
Two new application classes offering the calculation of ddimensional
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 ymonotone pieces is available.

Planar Maps and
Arrangements
 A new class Planar_map_with_intersections_2<Planar_map> for
planar maps of possibly intersecting, possibly nonxmonotone,
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 listbased
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 selfwritten 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 STLcompliant 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, nonreferencecounted 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 referencecounted 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 twodimensional 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.
