
-------------------------------- Release 4.9 --------------------------------

Release date: Sept 2016


* Header-only mode

  - CGAL can now be used in headers only mode, i.e. without compiling the CGAL
    libraries and linking with these libraries when compiling examples, tests
    and demos. Note that running CMake on CGAL is still required in order to
    generate some configuration files.


* Cone Based Spanners (new package)

  - This package provides algorithms for constructing two kinds of cone-based
    spanners: Yao graph and Theta graph, given a set of vertices on the plane
    and the directions of cone boundaries.


* 2D Minkowski Sums

  - Introduce a convex decomposition strategy, namely
    Polygon_nop_decomposition_2, that merely passed the input polygon to the
    list of output polygons.

  - Introduce overloads of the function minkowski_sum_2(), which accepts 2
    decomposition strategies.

  - Introduce an overloaded function called minkowski_sum_by_decomposition_2(P,
    Q, decom_no_holes, decomp_with_holes), which computes the 2D Minkowski sum
    using optimal choices of decomposition strategies.


* Combinatorial Maps

  - Deprecate global functions (make_combinatorial_hexahedron(),
    make_combinatorial_polygon(), make_combinatorial_tetrahedron(), make_edge
    (), insert_cell_0_in_cell_1(), insert_cell_0_in_cell_2(),
    insert_cell_1_in_cell_2(), insert_cell_2_in_cell_3(),
    insert_dangling_cell_1_in_cell_2(), is_insertable_cell_1_in_cell_2(),
    is_insertable_cell_2_in_cell_3(), is_removable(), remove_cell()) which are
    now member functions in the CombinatorialMap concept.

  - It is not longer possible to use the old API switched on by defining the
    macro CGAL_CMAP_DEPRECATED. This API was deprecated since CGAL 4.4.


* Point Set Processing

  - New function CGAL::read_ply_custom_points() that allows the user to read
    any additional point attribute from a PLY input point set.


* Point Set Shape Detection

  - New post-processing algorithm: CGAL::regularize_planes(). This allows the
    user to favor parallelism, orthogonality, coplanarity and/or axial symmetry
    between detected planes.


* Polygon Mesh Processing

  - Add the function CGAL::Polygon_mesh_processing::
    is_polygon_soup_a_polygon_mesh() to check whether a polygon soup is a
    polygon mesh.

  - Add some new features to CGAL::isotropic_remeshing():

      - It is now possible to select fixed vertices that survive the remeshing
        process, and to keep face attributes such as colors valid after
        remeshing.

      - The user can choose the number of relaxation steps happening at each
        loop, and to run 1-dimensional relaxation along constrained polylines.


  - The functions CGAL::Polygon_mesh_processing::triangulate_face() and CGAL::
    Polygon_mesh_processing::triangulate_faces() now indicate whether some
    faces have not been triangulated.


* Surface Mesh Deformation

  - Add a new tag SRE_ARAP to use the Smoothed Rotation Enhanced As-Rigid-As-
    Possible deformation algorithm.


* 3D Fast Intersection and Distance Computation

  - Add the functions AABB_tree::first_intersection() and AABB_tree::
    first_intersected_primitive() that compute the intersection which is
    closest to the source of a ray


* CGAL and the Boost Graph Library (BGL)

  - Add a helper function CGAL::copy_face_graph() to copy a source
    FaceListGraph into another FaceListGraph of different type.

  - Add a class CGAL::Dual that creates the dual view of a FaceGraph and a
    creation function CGAL::dual(primal).


 ** CGAL and Boost Property Maps

  - It is not longer possible to use the old API of the property maps provided
    by CGAL, switched on by defining the macro CGAL_USE_PROPERTY_MAPS_API_V1.
    This API was deprecated since CGAL 4.3.


-------------------------------- Release 4.8 --------------------------------

Release date: April 2016


* General

  - The support for Qt3 is dropped and all demos using it got removed.


* Installation

  - Starting with Visual C++ 2015 we no longer require Boost.Thread as we use
    the C++11 keyword thread_local and the C+11 class std::mutex .

  - The same holds for g++ 4.8 or later when the C++11 standard is used.


* Optimal Transportation Curve Reconstruction (new package)

  - This package implements a method to reconstruct and simplify 2D point sets.
    The input is a set of 2D points with mass attributes, possibly hampered by
    noise and outliers. The output is a set of line segments and isolated
    points which approximate the input points.


* 2D Regularized Boolean Set-Operations

  - Improve the performance of operations in some settings.
    Breaking change: This improvement requires changes of the face and halfedge
    type of the underlying arrangement Dcel. See the concepts
    GeneralPolygonSetDcelHalfedge and GeneralPolygonSetDcelFace for more
    details. If you use a different simplex types, inheriting your simplices
    from CGAL::Gps_face_base and CGAL::Gps_halfedge_base is sufficient to
    accommodate for the update.


* 3D Boolean Operations on Nef Polyhedra

  - Add 3 new constructors: from a point range, from a point, and from a
    segment.


* Combinatorial Maps

  - Breaking change: Change the type of Boolean marks, old type is int, new
    type is size_type. If no more mark is available, get_new_mark throws an
    exception, instead of returning -1.


* 2D Arrangements

  - Speed up the edge removal in case the incident faces contains many holes.

  - Set the format of polylines and polycurves. The format of a general
    polyline or polycurve consists of the sequence of subcurves that comprise
    the original curve. The format of a polyline of linear segments consists of
    the sequence of points that define the original curve. (The latter restores
    the format used before polycurves were introduced in 4.7.) Fix the
    extraction from istream and insertion into ostream operators of polylines
    and polycurves accordingly.

  - Fix the traits class that handles Bezier curves. In particular, fix the
    case where the curve is closed (i.e, the first and last control points
    coincide).


* 3D Mesh Generation

  - Add support of 3D gray level images as input for the tetrahedral mesh
    generation.

  - Breaking change: All models of the concept MeshDomain_3 must now provide a
    member function bbox().


* Advancing Front Surface Reconstruction

  - Optional template functor Filter is replaced by another optional template
    functor Priority. This allows to change the way facets are prioritized by
    the algorithm instead of having a simple option to reject some facets.
    Breaking change: Programs using the old Filter API will not compile anymore
    as it must be replaced with the Priority API as described in the manual.
    Codes using the default behavior are not impacted.


* Polygon Mesh Processing

  - Add a new triangle-based isotropic remeshing algorithm for triangulated
    surface meshes, CGAL::Polygon_mesh_processing::isotropic_remeshing() and a
    helper function for isotropic remeshing : CGAL::Polygon_mesh_processing::
    split_long_edges()

  - Add the function CGAL::Polygon_mesh_processing::border_halfedges() to
    collect the border of a given face range

  - Add the function CGAL::Polygon_mesh_processing::remove_isolated_vertices()
    to be used on any polygon mesh

  - Add the function CGAL::Polygon_mesh_processing::triangulate_face() to
    triangulate a single face of a polygon mesh

  - Add an overload for CGAL::Polygon_mesh_processing::triangulate_faces() to
    triangulate a range of faces of a polygon mesh

  - Add function keep_large_connected_components()

  - Add measuring functions for polygon meshes, to compute length, area, and
    volume of simplices or group of simplices of a polygon mesh.

  - Add function bbox_3() to compute the bounding box of a polygon mesh.


* Surface Mesh Parameterization

  - LSCM_parameterizer_3 now uses by default Eigen instead of OpenNL as a model
    of SparseLinearAlgebraTraits_d.


* Point Set Processing

  - Breaking change: new template parameter Concurrency_tag for the functions
    compute_average_spacing(), edge_aware_upsample_point_set(),
    jet_estimate_normals(), jet_smooth_point_set(), and pca_estimate_normals().
    To update your code simply add as first template parameter CGAL::
    Sequential_tag or CGAL::Parallel_tag when calling one of these functions.

  - CGAL::Parallel_tag can no longer be used in Point Set Processing algorithms
    if TBB is not available.

  - Add a new simplification algorithm based on hierarchical clustering: CGAL::
    hierarchy_simplify_point_set(). It allows either to uniformly simplify the
    point set or to automatically adapt the local density of points to the
    local variation of the input computed by principal component analysis.

  - New IO functions for PLY format (Polygon File Format): CGAL::
    read_ply_points(), CGAL::read_ply_points_and_normals(), CGAL::
    write_ply_points() and CGAL::write_ply_points_and_normals().


* Surface Mesh Parameterization

  - LSCM_parameterizer_3 now uses by default Eigen instead of OpenNL as a model
    of SparseLinearAlgebraTraits_d.


* Spatial Searching

  - Add function to find any point in a range query, that is neither all
    points, nor the closest one.


* Principal Component Analysis

  - Add a template parameter DiagonalizeTraits for functions CGAL::
    linear_least_squares_fitting_2() and CGAL::linear_least_squares_fitting_3
    (). This allows to either choose the legacy internal diagonalization code
    from CGAL or the Eigen implementation (or any class that is a model of
    DiagonalizeTraits). Variants of the function that automatically deduce the
    kernel also automatically select the diagonalizer, so the API is mostly
    preserved.


* CGAL and Solvers

  - This package now includes all CGAL concepts for solvers with models using
    the third party Eigen library.


* CGAL and the Boost Graph Library (BGL)

  - Add function CGAL::split_graph_into_polylines() that allows to extract from
    a soup of segments given as a graph, polylines with nodes of degree at most
    2. In addition a functor can be passed to the function to specify
    additional polyline endpoints.

  - New functions to manipulate selection of faces, edges and vertices in a
    halfedge graph are added: CGAL::expand_face_selection(), CGAL::
    reduce_face_selection(), CGAL::expand_edge_selection(), CGAL::
    reduce_edge_selection() CGAL::expand_vertex_selection(), CGAL::
    reduce_vertex_selection() and CGAL::select_incident_faces().

  - Add a helper function CGAL::clear which clears a MutableFaceGraph
    efficiently and generically.


-------------------------------- Release 4.7 --------------------------------

Release date: October 2015


* Installation

  - The minimum required version of CMake is now 2.8.11. CMake versions 3.1,
    3.2, and 3.3 are supported.

  - All Qt4 demos have been updated and now require Qt5 to be compiled. Qt5
    version 5.3 or higher is required. The support for Qt4 is dropped. To
    compile libCGAL_Qt5 and demos, you must set the cmake or environment
    variable Qt5_DIR to point to the path to the directory containing the file
    Qt5Config.cmake created by your Qt5 installation. If you are using the open
    source edition it should be /path-to/qt-everywhere-opensource-src-
    <version>/qtbase/lib/cmake/Qt5.

  - The code of the 3D demos now uses modern OpenGL, with shaders, instead of
    the fixed pipeline API of OpenGL-1.

  - The Microsoft Windows Visual C++ compiler 2015 (VC14) is now supported.
    However, since this compiler is not officially supported by Intel TBB 4.4
    and Qt 5.5 (the latest versions available at the time of this release), the
    parallelism features of CGAL and Qt5 demos will not work.


* L Infinity Segment Delaunay Graphs (new package)

  - The package provides the geometric traits for constructing the segment
    Delaunay graph in the max-norm (L Infinity). The traits also contain
    methods to draw the edges of the dual of the segment Delaunay graph in the
    max-norm i.e., the segment Voronoi diagram in the max-norm. The algorithm
    and traits rely on the segment Delaunay graph algorithm and traits under
    the Euclidean distance. The segment Voronoi diagram in the max-norm has
    applications in VLSI CAD.


* Advancing Front Surface Reconstruction (new package)

  - This package provides a greedy algorithm for surface reconstruction from an
    unorganized point set. Starting from a seed facet, a piecewise linear
    surface is grown by adding Delaunay triangles one by one. The most
    plausible triangles are added first, in a way that avoids the appearance of
    topological singularities.


* Triangulated Surface Mesh Shortest Paths (new package)

  - The package provides methods for computing shortest path on triangulated
    surface meshes. Given a set of source points on the surface, this package
    provides a data structure that can efficiently provides the shortest path
    from any point on the surface to the sources points. There is no
    restriction on the genus or the number of connected components of the mesh.


* Triangulated Surface Mesh Skeletonization (new package)

  - This package provides a (1D) curve skeleton extraction algorithm for a
    triangulated polygonal mesh without borders based on the mean curvature
    flow. The particularity of this skeleton is that it captures the topology
    of the input. For each skeleton vertex one can obtain its location and its
    corresponding vertices from the input mesh. The code is generic and works
    with any model of the `FaceListGraph` concept.


* 3D Point-Set Shape Detection (new package)

  - This package implements the efficient RANSAC method for shape detection,
    contributed by Schnabel et al. From an unstructured point set with
    unoriented normals, the algorithm detects a set of shapes. Five types of
    primitive shapes are provided by this package: plane, sphere, cylinder,
    cone and torus. Detecting other types of shapes is possible by implementing
    a class derived from a base shape.


* 2D Visibility (new package)

  - This package provides several variants to compute the visibility area of a
    point within polygonal regions in two dimensions.


* Polygon Mesh Processing (new package)

  - This package implements a collection of methods and classes for polygon
    mesh processing, ranging from basic operations on simplices, to complex
    geometry processing algorithms. The implementation of this package mainly
    follows algorithms and references given in Botsch et al.'s book on polygon
    mesh processing.


* General

  - Support for unordered sets and maps of the stdlib and of boost for handle
    and index classes.




* Approximation of Ridges and Umbilics on Triangulated Surface Meshes

  - This package now supports any model of the concept FaceGraph.

  - Breaking change: The package no longer supports models of
    TriangulatedSurfaceMesh which are not at the same time models of the
    concept FaceGraph.


* dD Geometry Kernel

  - Epick_d gains 3 new functors: Construct_circumcenter_d,
    Compute_squared_radius_d, Side_of_bounded_sphere_d. Those are essential for
    the computation of alpha-shapes.


* 2D Arrangements

  - Introduced a new traits class, called
    Arr_polycurve_traits_2<SubcurveTraits>, which handles general piece-wise
    (polycurve) curves. The pieces do not necessarily have to be linear.

  - Introduced two new concepts called ArrangementApproximateTraits_2 and
    ArrangementConstructXMonotoneCurveTraits_2.

      - The existing ArrangementLandmarkTraits_2 concept, which has two
        requirements, now refines the two respective concepts above.

      - The template parameter of the existing
        Arr_polyline_traits_2<SegmentTraits> template must be substituted with
        a traits class that is a model of the
        ArrangementConstructXMonotoneTraits_2 concept among the other when
        Arr_polyline_traits_2 is instantiated.



* 2D Minkowski Sums

  - Added support for polygons with holes and optimized the construction of
    Minkowski sums.

      - Introduced an implementation of the "reduced convolution" method, a
        variant of the method described in "2D Minkowski Sum of Polygons Using
        Reduced Convolution" by Behar and Lien. The new method supports
        polygons with holes and in many cases out pergorms the implementation
        of the exsisting (full) convolution method.

      - Introduced two new classes that decompose polygons into convex pieces
        (models of the PolygonConvexDecomposition_2 concept) based on vertical
        decomposition and constrained Delaunay triangulation, respectively.
        These new models also support the convex decomposition of polygons with
        holes.



* 3D Periodic Triangulations

  - Rename Periodic_3_triangulation_traits_3 to
    Periodic_3_Delaunay_triangulation_traits_3.

  - Rename the concept Periodic_3TriangulationTraits_3 to
    Periodic_3DelaunayTriangulationTraits_3.

  - Create Periodic_3_triangulation_traits_3 and the concept
    Periodic_3TriangulationTraits_3.


* 2D Conforming Triangulations and Meshes

  - Add an optimization method CGAL::lloyd_optimize_mesh_2() that implements
    the Lloyd (or Centroidal Voronoi Tesselation) optimization algorithm in a
    Constrained Delaunay Triangulation. For optimization, the triangulation
    data structure on which the mesher relies needs its VertexBase template
    parameter to be a model of the new concept DelaunayMeshVertexBase_2.


* Point Set Processing and Surface Reconstruction from Point Sets

  - Add the function CGAL::compute_vcm() for computing the Voronoi Covariance
    Measure (VCM) of a point set. The output of this function can be used with
    the function CGAL::vcm_is_on_feature_edge() to determine whether a point is
    on or close to a feature edge. The former function is also internally used
    by CGAL::vcm_estimate_normals() to estimate the normals of a point set and
    it is particularly suited to point sets with noise.


* Spatial Sorting

  - Add the possibility to sort points on a sphere along a space-filling curve
    using the functions CGAL::hilbert_sort_on_sphere and CGAL::
    spatial_sort_on_sphere.


* Geometric Object Generators

  - Add new random generator of points in a 2D and 3D triangle and in a
    tetrahedron (CGAL::Random_points_in_triangle_2, CGAL::
    Random_points_in_triangle_3, CGAL::Random_points_in_tetrahedron_3).


-------------------------------- Release 4.6.2 --------------------------------

Release date: August 2015

This release only fixes bugs. See the list of fixed bugs on Github:

https://github.com/CGAL/cgal/issues?q=milestone%3A4.6.2


-------------------------------- Release 4.6.1 --------------------------------

Release date: June 2015

This release only fixes bugs. See the list of fixed bugs on Github:

https://github.com/CGAL/cgal/issues?q=milestone%3A4.6.1+-label%3Ainvalid


-------------------------------- Release 4.6 --------------------------------

Release date: April 2015


* Installation

  - The required version of Boost is now 1.48 or higher.


* 2D Polyline Simplification (new package)

  - This package enables to simplify polylines with the guarantee that the
    topology of the polylines does not change. This can be done for a single
    polyline as well as for a set of polyline constraints in a constrained
    triangulation. The simplification can be controlled with cost and stop
    functions.


* 2D Generalized Barycentric Coordinates (new package)

  - This package offers an efficient and robust implementation of two-
    dimensional closed-form generalized barycentric coordinates defined for
    simple two-dimensional polygons.


* Scale-Space Surface Reconstruction (new package)

  - This new package provides a class gathering a dedicated smoothing algorithm
    and some convenience functions to help the creation of a surface out of a
    point set using the 3D Alpha Shapes package. The particularity of this
    reconstruction pipeline is that the input point are in the output and no
    new points are created. Note that in the current version, the output is a
    triangle soup that is not necessarily a valid (manifold) polyhedral
    surface.


* Surface Mesh (new package)

  - The surface mesh class provided by this package is an implementation of the
    halfedge data structure allowing to represent polyhedral surfaces. It is an
    alternative to the packages CGAL::Polyhedron_3 and CGAL::HalfedgeDS.


* dD Triangulation (new package)

  - This new package provides classes for manipulating triangulations in
    Euclidean spaces whose dimension can be specified at compile-time or at
    run-time. It also provides a class that represents Delaunay triangulations.


* dD Convex Hulls and Delaunay Triangulations

  - This package is deprecated and the new package Triangulation should be used
    instead.




* dD Geometry Kernel

  - It has been reported that the recently introduced Epick_d kernel may not
    work with Intel C++ Compiler prior to version 15. Documentation has been
    updated.


* 3D Convex Hulls

  - Add functions halfspace_intersection_3 and
    halfspace_intersection_with_constructions_3 to compute the intersection of
    halfspaces defining a closed polyhedron.

  - Fix a bug introduced in CGAL 4.5 that can appear while computing the convex
    hull of coplanar points.

  - Fix a robustness issue in Convex_hull_traits_3. This traits is used by
    default with the kernel Exact_predicates_inexact_constructions_kernel.

  - The function CGAL::convex_hull_incremental_3 is deprecated and the function
    convex_hull_3 should be used instead.




* Combinatorial Maps and Linear Cell Complex

  - Added correct_invalid_attributes, set_automatic_attributes_management and
    are_attributes_automatically_managed methods in CombinatorialMap concept.
    This allows high level operations to not update non void attributes during
    massive calls of these operations, but only after the end of their
    executions.




* 2D Triangulations

  - The class Constrained_triangulation_plus_2 now can handle polylines as
    constraints.

  - As a consequence a Constraint_id has been introduced which replaces
    pair<Vertex_handle,Vertex_handle> as identifier of a constraint.




* 3D Mesh Generation

  - Add member functions output_boundary_to_off and
    output_facets_in_complex_to_off in the class CGAL::
    Mesh_complex_3_in_triangulation_3 to export the boundary of a domain or a
    subdomain.




* 3D Fast Intersection and Distance Computation

  - Add new constructors to AABB_halfedge_graph_segment_primitive and
    AABB_face_graph_triangle_primitive in order to be able to build primitives
    one by one.


* Spatial Searching

  - Fixed a bug in CGAL::Splitters.h sliding midpoint rule, where degenerated
    point sets (e.g.,points on segment) caused the kd-tree to get linear.

  - Improved performance of Orthogonal_k_neighbor_search. Note that VC 2013
    does not compile boost::container::deque of Boost 1_55 and does hence have
    a workaround which does not have the improvement.

  - Breaking change: The concept OrthogonalDistance has new function overloads
    for min_distance_to_rectangle and max_distance_to_rectangle with an
    additional reference parameter std::vector.

  - Breaking change: The order of the points in the iterator range [tree.begin
    (),tree.end()] is not the order of insertion of the points into the tree.
    This was not guaranteed before but might have been observed and exploited
    by users.

  - Derived kd_tree_leaf_node and kd_tree_internal_node from kd_tree_node to
    save memory.




* Geometric Object Generators

  - Add a new function random_convex_hull_in_disc_2 that efficiently generates
    a random polygon as the convex hull of uniform random points chosen in a
    disc.


-------------------------------- Release 4.5.2 --------------------------------

Release date: February 2015


* General

  - Fix a bug that prevented the compilation with recent versions of Boost
    (>=1.56) when explicit conversions operators (from C++11) are supported.
    That prevented the compilation with Microsoft Visual Studio 2013.


* 3D Convex Hulls

  - Fix a non-robust predicate bug that was showing up when input points where
    lexicographically sorted.


* 3D Mesh Generation

  - Fix a bug in the sliver perturbation optimization method. It could create
    some holes on the surface of the mesh.


-------------------------------- Release 4.5.1 --------------------------------

Release date: December 2014


* 3D Mesh Generation

  - Fix a bug in the sliver exudation preservation of boundaries.


-------------------------------- Release 4.5 --------------------------------

Release date: October 2014


* Installation

  - Changes in the set of supported platforms:

      - The Microsoft Windows Visual C++ compiler 2008 (VC9) is no longer
        supported since CGAL-4.5.


  - Since CGAL version 4.0, Eigen was the recommended third-party library to
    use with Planar Parameterization of Triangulated Surface Meshes, Surface
    Reconstruction from Point Sets, Approximation of Ridges and Umbilics on
    Triangulated Surface Meshes, and Estimation of Local Differential
    Properties of Point-Sampled Surfaces packages. From CGAL version 4.5,
    Taucs, Blas and Lapack are no longer supported.

  - CGAL is now compatible with the new CMake version 3.0.


* Triangulated Surface Mesh Deformation (new package)

  - This package allows to deform a triangulated surface mesh under positional
    constraints of some of its vertices without requiring any additional
    structure other than the surface mesh itself. The methods provided
    implements an as-rigid-as-possible deformation. Note that the main class
    name has changed between the 4.5-beta1 and the 4.5 releases to better match
    the CGAL naming conventions (from CGAL::Deform_mesh to CGAL::
    Surface_mesh_deformation).


* CGAL and the Boost Graph Library (major changes)

  - Cleanup of the HalfedgeGraph concept. In particular:

      - Introduction of the notion of halfedge_descriptor in the specialization
        of the class boost::graph_traits.

      - Deprecation of halfedge_graph_traits.

      - A model of HalfedgeGraph is considered as an undirected graph. Thus any
        call to edges() should be replaced by halfedges() and num_edges() now
        returns the number of (undirected) edges.

      - Breaking change: is_border_edge and is_border_halfedge properties are
        removed. The free functions is_border() and is_border_edge() should be
        used instead.

      - Renaming of HalfedgeGraph specific free functions.


  - Introduction of the FaceGraph concept.

  - Adaptation of the package Triangulated Surface Mesh Simplification and of
    the class AABB_halfedge_graph_segment_primitive from the package 3D Fast
    Intersection and Distance Computation to the API change.

  - Update of the package Triangulated Surface Mesh Segmentation and of the
    class AABB_face_graph_triangle_primitive from the package 3D Fast
    Intersection and Distance Computation to accept model of the newly
    introduced concepts.

  - Offer Euler operations as free functions for models of the graph concepts
    provided by CGAL.

  - Specialization of boost::graph_traits for OpenMesh::PolyMesh_ArrayKernelT
    as proof of concept. A OpenMesh::PolyMesh_ArrayKernelT becomes a model of
    the aforementioned concepts when including CGAL/boost/graph/
    graph_traits_PolyMesh_ArrayKernelT.h.


* dD Geometry Kernel

  - A new model Epick_d of the Kernel_d concept is introduced. It provides
    better performance through arithmetic filtering and specializations for
    fixed dimensions. It may not work with compilers as old as gcc-4.2, but was
    tested with gcc-4.4.


* 3D Convex Hulls

  - Clean up the documentation of the concepts


* 2D Arrangements

  - Fixed a bug in removing an unbounded curve (e.g., a ray) from an
    arrangement induced by unbounded curves.


* 2D Snap Rounding

  - Replaced use of private kd_tree with CGAL's official Kd_tree from
    Spatial_searching package; results in a small performance gain. Removed the
    private kd_tree package.


* 3D Triangulations

  - Add an experimental parallel version of the Delaunay triangulation and the
    regular triangulation algorithms, which allows parallel insertion and
    removal of point ranges.

  - Add caching of circumcenters to Regular_triangulation_cell_base_3. The
    cache value is computed when cell->circumcenter() or rt.dual(cell)
    functions are called.


* 3D Periodic Triangulations

  - Add a method to locate point with inexact predicates.


* 3D Mesh Generation

  - Add a new constructor for the class Labeled_mesh_domain_3 which takes an
    Iso_cuboid_3.

  - Add a new labeling function wrapper for meshing multi-domain.

  - The meshing functionality in the Qt demos in demo/Polyhedron/ and demo/
    Mesh_3/ can now use the handling of 1d-features, that exists in CGAL since
    version 3.8.

  - Add an experimental parallel version of the 3D mesh refinement and mesh
    optimization methods.


* Point Set Processing and Surface Reconstruction from Point Sets

  - The former demo has been removed and is fully merge in the Polyhedron demo.


* Point Set Processing

  - Workaround a bug in dijsktra shortest path of boost 1.54 by shipping and
    using the boost header from the 1.55 release. This header will be used only
    if you are using the version 1.54 of boost.


* Triangulated Surface Mesh Simplification

  - Breaking change: Due to the cleanup of the concepts of the package CGAL and
    the Boost Graph Library, the named parameter edge_is_border_map has been
    removed, and the named parameter edge_is_constrained_map now expects a
    property map with an edge descriptor as key type (vs. halfedge descriptor
    before).

  - Add some optimization in the code making the implementation faster
    (depending on the cost and the placement chosen). However, for an edge
    which collapse is not topologically valid, the vector of vertices of the
    link provided by its profile might contains duplicates, thus also breaking
    the orientation guarantee in the vector. This must not be a problem for
    users as the edge is not collapsible anyway but if it is a absolute
    requirement for user defined cost/placement, defining the macro
    CGAL_SMS_EDGE_PROFILE_ALWAYS_NEED_UNIQUE_VERTEX_IN_LINK will restore the
    former behavior.


* dD Spatial Searching

  - Added methods reserve(size_t size) and size_t capacity() to class Kd_tree
    to allocate memory to store size points and to report that number (STL
    compliance).


* STL Extensions for CGAL

  - Add Compact_container::operator[], allowing a direct access to the ith
    element of a compact container.

  - Add Concurrent_compact_container, a compact container which allows
    concurrent insertion and removal.


-------------------------------- Release 4.4 --------------------------------

Release date: April 2014


* Installation

  - Additional supported platforms:

      - The Apple Clang compiler version 5.0 is now supported on
        OS X Mavericks.

      - The Microsoft Windows Visual C++ compiler 2013 (VC12) is now supported.



* Triangulated Surface Mesh Segmentation (new package)

  - This package implements the segmentation of triangulated surface meshes
    based on the Shape Diameter Function (SDF). In addition, it also provides
    functions to generate segmentations based on a user defined alternative to
    the SDF.


* Number Types

  - A new class CGAL::Mpzf is introduced on some platforms for exact ring
    operations. It is used to improve the speed of the evaluation of predicates
    in degenerate situations.


* 2D and 3D Geometry Kernel

  - Fix a bug introduced in CGAL 4.3 when computing the intersection of two 3D
    triangles.


* 2D Polygon Partitioning

  - Bug fix to make the partition algorithms working with a Lazy kernel such as
    Exact_predicates_exact_constructions_kernel.


* 2D Regularized Boolean Set-Operations

  - Fix two memory leaks in CGAL::General_polygon_set_2.


* Combinatorial Maps and Linear Cell Complex

  - null_dart_handle is no longer a static data member in the CombinatorialMap
    concept. This implies to move the following methods of Dart concept into
    CombinatorialMap concept: is_free, highest_nonfree_dimension, opposite and
    other_extremity. We also transform the static methods vertex_attribute and
    point of Linear_cell_complex class into non static methods. You can define
    the CGAL_CMAP_DEPRECATED macro to keep the old behavior.


* 2D Arrangements

  - Revise the API of polylines. In particular, construction is now done using
    functors and iteration is possible only on the segments of a polyline.

  - Fix a bug in the Landmark point-location strategy.


* 2D Snap Rounding

  - Fix a memory leak


* 2D Triangulations

  - Add different overloads of the function insert_constraints that inserts a
    range of points and segments, or a range of segments. These functions uses
    the spatial sorting in order to speed up the time needed for the insertion.


* 3D Alpha Shapes

  - Add member functions in CGAL::Alpha_shape_3 to give access to the alpha
    status of edges and facets (get_alpha_status()).

  - Add another filtration method (filtration_with_alpha_values()) that reports
    the alpha value at which each face appears in the filtration.


* 3D Mesh Generation

  - Fix the access to functions number_of_facets and number_of_cells in
    Mesh_complex_3_in_triangulation_3.

  - Change the internal API of the sliver perturber, to make possible for
    developers to optimize another criterion than the (default) minimal
    dihedral angle. Developers can also define a new perturbation vector (for
    angles we had gradient of squared circumradius, gradient of volume,
    gradient of minimal dihedral angle, and random) which is better suitable to
    optimize their criterion.

  - Improve the use of cache values in Mesh_cell_base_3 to (re)compute
    circumcenters and sliver criterion values only when needed.


* Triangulated Surface Mesh Simplification

  - Fix a bug in the way edges can be marked as non-removable by adding a
    named-parameter edge_is_constrained_map to the function edge_collapse


* dD Spatial Searching

  - Fix a documentation bug: The property map passed as template parameter to
    the classes Search_traits_adapter and Distance_adapter must be a lvalue
    property map. To avoid incorrect usage, a static assertion has been added
    in the CGAL code to prevent the user from instantiating these classes with
    an incorrect property map type.


* CGAL ipelets

  - Better description of the demo ipelets in the user manual

  - New ipelet for pencils of circles

  - New ipelet for hyperbolic geometry in Poincaré model

  - The generator ipelet now generates point in a selected zone

  - Hilbert sort ipelet implements two policies


-------------------------------- Release 4.3 --------------------------------

Release date: October 2013


* The CGAL Manual

  - The documentation of CGAL is now generated with Doxygen.


* 2D Periodic Triangulations (new package)

  - This package allows to build and handle triangulations of point sets in the
    two dimensional flat torus. Triangulations are built incrementally and can
    be modified by insertion or removal of vertices. They offer point location
    facilities. The package provides Delaunay triangulations and offers nearest
    neighbor queries and primitives to build the dual Voronoi diagrams.


* API Changes

 ** 2D and 3D Geometry Kernel

  - The intersection functions and functors used to return a CGAL::Object in
    order to deal with the different possible return types. However, depending
    on the arguments it is possible to reduce the possible return types to a
    small set. For this reason and to take advantage of the type safety, we
    decided to use boost::variant instead of CGAL::Object. The result_of
    protocol is now even more useful to determine the return type of the
    intersection functions and functors. The change should be relatively
    transparent to the user thanks to the implicit constructor added to CGAL::
    Object. However, it is recommended to upgrade your code. The previous
    behavior can be restored by defining the macro CGAL_INTERSECTION_VERSION
    to 1.


 ** 2D Arrangements

  - The type of the result of point location queries changed to boost::variant
    (from CGAL::Object). For convenience, the previous behavior can be restored
    by defining the macro CGAL_ARR_POINT_LOCATION_VERSION to 1.

  - Introduced an optimization for operations on large and dense arrangements.


 ** 3D Fast Intersection and Distance Computation

  - Following the intersection API change, Object_and_primitive_id has been
    replaced by a template class Intersection_and_primitive_id<Query> to
    determine the type depending on the query object type.


 ** CGAL and Boost Property Maps

  - The key_type of the property maps provided by CGAL used to be an iterator.
    In order to be more easily re-used, the key_type has been changed to be the
    value_type of the iterator. The packages that have been updated to match
    these changes are Point Set Processing and Surface Reconstruction from
    Point Sets. However, for most users this change should be transparent if
    the default property maps were used. For convenience, the former behavior
    can be enabled by defining the macro CGAL_USE_PROPERTY_MAPS_API_V1.


* Algebraic Foundations

  - For convenience, add an overload of make_rational() taking a pair of
    numbers.


* 2D and 3D Geometry Kernel

  - A Iso_rectangle_2 can now be constructed from a Bbox_2 and an Iso_cuboid_3
    from a Bbox_3.

  - The implementation of CGAL::Object has been updated and now uses boost::
    shared_ptr and boost::any. This implementation is faster.

  - Add to Bbox_2 and Bbox_3 a += operator as well as free functions to get the
    bounding box of a range of geometric objects.


* Combinatorial Maps

  - Two bug fixes: do not use the 2 least significant bits for cell attribute
    without dart support; share the mark when copying a CMap_cell_iterator.

  - Add a constructor taking a given combinatorial map as argument, possibly
    with different dimension and/or different attributes. This allows to
    transform a combinatorial map.

  - Add operator= and swap method.

  - Add dynamic onmerge/onsplit functions that can be associated dynamically to
    i-attributes and which are automatically called when i-cells are split/
    merged.

  - Add a function allowing to reverse the orientation of a combinatorial map,
    and another one to reverse one connected component of a combinatorial map.


* 3D Boolean Operations on Nef Polyhedra

  - Bug-fix in IO when using Lazy_exact_nt as number type or
    Exact_predicates_exact_constructions_kernel as kernel.


* 2D Triangulations

  - Extend the concept TriangulationDataStructure_2 to require a more general
    copy_tds function that allows a copy between TDS of different types. The
    CGAL model has been updated.

  - Add a way to efficiently insert a range of points with information into the
    2D constrained Delaunay triangulations.


* 3D Triangulations

  - Extend the concept TriangulationDataStructure_3 to require a more general
    copy_tds function that allows a copy between TDS of different types. The
    CGAL model has been updated.

  - Add an advanced function to set the infinite vertex of the triangulation
    for low level operations

  - Fix a bug in the function inserting a range of points with info when the
    Fast_location tag is used


* 2D Segment Delaunay Graph

  - Add functions insert_points and insert_segments to insert a range of points
    and segments. These functions uses the spatial sorting in order to speed up
    the time needed for the insertion. The function insert(Input_iterator
    first, Input_iterator beyond, Tag_true) has been updated to dispatch the
    input when possible to these functions.


* 2D Apollonius Graphs

  - Modified insertion algorithm so that the code can handle pseudo-circles as
    well.

  - Updated implementation of the vertex conflict predicate by a faster
    version.


* 3D Mesh Generation

  - Speed-up Mesh_3 and in particular the global optimizers (Lloyd and ODT) by
    introducing a parameter do_freeze to prevent from moving vertices which
    would move of very small displacements.

  - Introduce new data structures and options for speed-up and compacity. Note
    that Compact_mesh_cell_base_3 and Mesh_vertex_base_3 are now our favoured
    implementations of the concepts MeshCellBase_3 and MeshVertexBase_3.

  - Introduce a new constructor for Polyhedral_mesh_domain_3 that takes a
    bounding polyhedron to be meshed along with a polyhedral surface entirely
    included in it. This allows the user to mesh a polyhedral domain with
    internal surface(s) which can be non-watertight and even non-manifold.

  - Several documentation bug fixes.

  - Provide the ability to plug in custom cell_base/vertex_base classes into
    the Mesh_triangulation_3 class.


* Triangulated Surface Mesh Simplification

  - Fix a segmentation fault that was happening when some edges of length 0
    were in the input mesh.


* 3D Fast Intersection and Distance Computation

  - Following the intersection API change, Object_and_primitive_id has been
    replaced by a template class Intersection_and_primitive_id<Query> to
    determine the type depending on the query object type.

  - Introduce the class AABB_halfedge_graph_segment_primitive, which replaces
    the class AABB_polyhedron_segment_primitive (which is now deprecated). The
    new class is more general and can be used with any model of HalfedgeGraph.

  - Introduce the class AABB_face_graph_triangle_primitive which replaces the
    class AABB_polyhedron_triangle_primitive (which is now deprecated).

  - Document the classes AABB_segment_primitive and AABB_triangle_primitive
    that were already used in some examples.

  - Add a generic primitive class AABB_primitive that allows to define a
    primitive type by defining only two property maps.

  - Introduce a new concept of primitive AABBPrimitiveWithSharedData. It allows
    to have some data shared between the primitives stored in a AABB_tree. With
    this you can, for example have a primitive wrapping an integer which refers
    to the position of a geometric object in a std::vector. Only one reference
    to this vector will be stored in the traits of the tree. The concept
    AABBTraits, its model AABB_traits and the class AABB_tree have been updated
    accordingly. However, everything is backward compatible.

  - Fix a memory leak in the destructor of the class AABB-tree


* STL Extensions for CGAL

  - Add to Dispatch_output_iterator and Dispatch_or_drop_output_iterator an
    operator to accept and dispatch a tuple of values.


* Concurrency in CGAL

  - Add a FindTBB CMake module so that one can easily link with TBB to write
    shared-memory parallel code.

  - Introduce two new tags: Sequential_tag and Parallel_tag


-------------------------------- Release 4.2 --------------------------------

Release date: March 2013


* Installation

  - Additional supported platforms:

      - The Microsoft Windows Visual C++ compiler 2012 (VC11) is now supported.


  - With Microsoft Visual C++ (all supported versions), the compiler flags /
    bigobj and /wd4503 are added by CGAL CMake scripts.

  - This is the last release whose "UseCGAL.cmake" file (if using CGAL in a
    CMake build environment) contains the line
      link_libraries(${CGAL_LIBRARIES_DIR} ${CGAL_3RD_PARTY_LIBRARIES_DIRS})
    as this is a deprecated CMake command. The correct way to link with CGAL's
    libraries (as for required 3rd party libraries) is to use
    'target_link_libraries' which specifies for each build target which
    libraries should be linked. The following serves as example:
      find_package(CGAL)
      include(${CGAL_USE_FILE})
      add_executable(myexe main.cpp)
      target_link_libraries(myexe ${CGAL_LIBRARIES}
                                  ${CGAL_3RD_PARTY_LIBRARIES})
    We also expect further changes in CGAL's CMake setup (change of variable
    names, consistency of filename and output, removing essential libraries,
    building executables, removal of '${CGAL_3RD_PARTY_LIBRARIES}').


* 2D Arrangements

  - Enhanced the 2D-arrangements demonstration program and ported it to Qt4.
    The new demonstration program makes use of the CGAL Graphics View
    framework, in which the 2D primitives are individually represented as
    objects in a scene. (The implementations of several demos in CGAL already
    make use of this framework.) This project was carried out as part of the
    2012 Google Summer of Code program.

  - Fixed a bug in the Walk-Along-A-Line point location strategy for
    arrangements induced by unbounded curves.


* 2D Circular Geometry Kernel

  - Fix the intersection type computed when intersecting two identical circles.

  - Forward correctly the result type of the linear kernel functors


* 2D Triangulations

  - Add mechanism to avoid call stack overflow in Delaunay_triangulation_2 and
    Constrained_Delaunay_triangulation_2.

  - Add a constructor for Regular_triangulation_2 and Delaunay_triangulation_2
    from a range of points or a range of points with info.


* 2D Voronoi Diagram Adaptor

  - Bug-fix: Add ccb() method in face type as documented.


* 3D Minkowski Sum of Polyhedra

  - Fix a memory leak.


* 3D Fast Intersection and Distance Computation

  - Update requirements of the concepts AABBTraits and AABBGeomTraits to match
    the implementation of the package.


* Generator

  - Addition of the Combination_enumerator


* STL Extensions

  - Introduction of CGAL::cpp11::result_of as an alias to the tr1
    implementation from boost of the result_of mechanism. When all compilers
    supported by CGAL will have a Standard compliant implemention of the C++11
    decltype feature, it will become an alias to std::result_of.


* Surface Reconstruction from Point Sets

  - Performance improvements and addition of an option to better reconstruct
    undersampled zones. The poisson reconstruction plugin of the Polyhedron
    demo has an option to switch it on.


-------------------------------- Release 4.1 --------------------------------

Release date: October 2012


* Installation

  - Additional supported platforms:

      - The Apple Clang compiler versions 3.1 and 3.2 are now supported on
        Mac OS X.


  - Improved configuration for essential and optional external third party
    software

  - Added more general script to create CMakeLists.txt files:
    cgal_create_CMakeLists

  - Availability tests for C++11 features are now performed with the help of
    Boost.Config. A Boost version of 1.40.0 or higher is needed to use C++11
    features.


* 2D Arrangement

  - Improved the implementation of the incremental randomized trapezoidal
    decomposition point-location strategy. The new implementation enables point
    location in unbounded arrangements. It constructs a search structure of
    guaranteed linear size with guaranteed logarithmic query time.


* 2D Convex Hulls and Extreme Points

  - Speed up the preprocessing stage of the Akl-Toussaint implementation (used
    by the free function convex_hull_2 when forward iterators are provided as
    input).


* Combinatorial Maps

  - Minor bugfix; replace some functors by methods.


* Linear Cell Complex

  - Improve the demo: add a widget showing all the volumes and an operation to
    create a Menger sponge.


* Kernels

  - All Kernel functors now support the result_of protocol.


* STL_Extensions for CGAL

  - The namespace cpp0x has been renamed cpp11. The old name is still available
    for backward compatibility.


-------------------------------- Release 4.0.2 --------------------------------

Release date: Jul 2012

This is a bug fix release. It fixes a bug in the CMakeLists.txt for CGAL-4.0.1,
that prevented even building the libraries.


-------------------------------- Release 4.0.1 --------------------------------

Release date: Jul 2012

This is a bug fix release. Apart various minor fixes in the documentation, the
following has been changed since CGAL-4.0:


* 2D Voronoi Diagram Adaptor (re-added)

  - The package 2D Voronoi Diagram Adaptor was temporarily removed from the
    CGAL distribution because of license issues. That package is now back into
    CGAL.


* 2D and 3D Geometry Kernel

  - Fix a bug in the Segment_3-Triangle_3 intersection function in the case the
    segment is collinear with a triangle edge.

  - Fix a bug in the Projection_traits_.._3 class in the case a segment was
    parallel to the x-axis.


* Algebraic Kernel

  - Avoid the linking error "duplicate symbols" when two compilation units
    using the algebraic kernel are linked.


* 3D Boolean Operations on Nef Polygons Embedded on the Sphere

  - Fix a memory leak due to the usage of an internal mechanism that has been
    replaced by boost::any. This also influences the packages 2D Boolean
    Operations on Nef Polygons, 3D Boolean Operations on Nef Polyhedra, Convex
    Decomposition of Polyhedra, and 3D Minkowski Sum of Polyhedra.


* 2D Arrangement

  - Fix several memory leaks.


* 2D Mesh Generation

  - Fix a compilation error in the header <CGAL/Mesh_2/Do_not_refine_edges.h>
    when g++ version 4.7 is used.


* Surface Mesh Generation and 3D Mesh Generation

  - Fix an important bug in the CGAL_ImageIO library, that could lead to wrong
    result when meshing from a 3D image.

  - Fix the compilation of the demo in demo/Surface_mesher, when Boost version
    1.48 or 1.49 is used.


* Surface Mesh Parameterization

  - Fix a memory leak.

  - Fix a compatibility issue with Eigen-3.1 of Eigen_solver_traits. This fix
    also affects the usage of that class in the package Surface Reconstruction
    from Point Sets.


-------------------------------- Release 4.0 --------------------------------

Release date: March 2012

CGAL 4.0 offers the following improvements and new functionality :


* License Changes
The whole CGAL-3.x series was released under a combination of LGPLv2 (for the
foundations of CGAL), and QPL (for the high-level packages). QPL was the former
license of the graphical toolkit Qt, but that license is not supported by any
major free software project. Furthermore, the terms of the LGPLv2 license are
ambiguous for a library of C++ templates, like CGAL.

The CGAL project, driven by the CGAL Editorial Board, has decided to change the
license scheme of CGAL. We increased the major number of the CGAL version to
'4' in order to reflect this license change. The CGAL-4.x series is released
under:


  - LGPLv3+ (that is LGPL "either version 3 of the License, or (at your option)
    any later version"), for the foundations of CGAL, instead of LGPLv2,

  - GPLv3+ for the high-level packages, instead of QPL.


* General

  - On Windows, CGAL libraries are now built by default as shared libraries
    (also called DLL). To run applications that use .dll files of CGAL, you
    must either copy the .dll files into the directory of the application, or
    add the path of the directory that contains those .dll files into the PATH
    environment variable.

  - On Windows, the CMake scripts of CGAL now search for shared version of the
    Boost libraries. You must ensure that the .dll files of Boost are found by
    the dynamic linker. You can, for example, add the path to the Boost .dll
    files to the PATH environment variable.

  - On Windows, CMake version 2.8.6 or higher is now required.

  - Eigen version 3.1 or later is now the recommended third party library to
    use in Planar Parameterization of Triangulated Surface Meshes, Surface
    Reconstruction from Point Sets, Approximation of Ridges and Umbilics on
    Triangulated Surface Meshes, and Estimation of Local Differential
    Properties of Point-Sampled Surfaces packages. If you use Eigen you no
    longer need Taucs, Lapack or Blas to use those packages (and any other in
    CGAL).


* Linear Cell Complex (new package)

  - This package implements linear cell complexes, objects in d-dimension with
    linear geometry. The combinatorial part of objects is described by a
    combinatorial map, representing all the cells of the object plus the
    incidence and adjacency relations between cells. Geometry is added to
    combinatorial maps simply by associating a point to each vertex of the map.
    This data structure can be seen as the generalization in dD of the
    Polyhedron_3.


* 2D Voronoi Diagram Adaptor (temporarily removed)

  - As the copyright holder of this package has not granted the right to switch
    from QPL to GPL, this package is removed from the distribution. Note that
    it is "only" an adapter, that is the functionality of point/segment/disk
    Voronoi diagram is offered through the Delaunay triangulation, segment
    Delaunay graph, and Apollonius graph.


* AABB Tree

  - Document constness of member functions of the AABB_tree class.

  - The class AABB_tree is now guaranteed to be read-only thread-safe. As usual
    in CGAL, this small overhead introduced for thread-safety can be
    deactivated by defining CGAL_HAS_NO_THREADS.


* 2D Alpha Shapes

  - Add an extra template parameter to the class Alpha_shape_2 that allows a
    certified construction using a traits class with exact predicates and
    inexact constructions.

  - An object of type Alpha_shape_2 can now be constructed from a
    triangulation.


* 3D Alpha Shapes

  - Add an extra template parameter to the class Alpha_shape_3 that allows a
    certified construction using a traits class with exact predicates and
    inexact constructions.


* Geometric Object Generators

  - Random_points_in_iso_box_d (deprecated since 3.8) has been removed. Use
    Random_points_in_cube_d instead.


* Linear and Quadratic Programming Solver

  - Minor bugfix.


* Spatial Searching

  - The const-correctness of this package have been worked out. The transition
    for users should be smooth in general, however adding few const in user
    code might be needed in some cases.

  - The class Kd_tree is now guaranteed to be read-only thread-safe. As usual
    in CGAL, this small overhead introduced for thread-safety can be
    deactivated by defining CGAL_HAS_NO_THREADS.

  - Bug-fix in Orthogonal_incremental_neighbor_search and
    Incremental_neighbor_search classes. Several calls to begin() now allow to
    make several nearest neighbor search queries independently.


* STL Extension

  - CGAL::copy_n is now deprecated for CGAL::cpp0x::copy_n which uses std::
    copy_n, if available on the platform.

  - CGAL::successor and CGAL::predecessor are now deprecated for CGAL::cpp0x::
    next and CGAL::cpp0x::prev. These functions use the standard versions if
    available on the platform. Otherwise, boost::next and boost::prior are
    used.


* Triangulation_2

  - Fix a thread-safety issue in Delaunay_triangulation_2 remove functions. As
    usual in CGAL, the small overhead introduced for thread-safety can be
    deactivated by defining CGAL_HAS_NO_THREADS.

  - Add extraction operator for the class Constrained_triangulation_2 (and thus
    to all inheriting classes).


-------------------------------- Release 3.9 --------------------------------

Release date: September 2011

CGAL 3.9 offers the following improvements and new functionality :


* General

  - The class Root_of_2 is now deprecated. It is recommended to use the class
    Sqrt_extension instead.

  - The class Sqrt_extension is now used everywhere in CGAL where an algebraic
    number of degree 2 is needed. This change has been done in the
    Root_of_traits mechanism (indirectly packages 2D Circular kernel and 3D
    Spherical kernel) and the packages 2D Segment Delaunay Graphs and 2D
    Arrangements.

  - Various fixes in the manual.


* Combinatorial Maps (new package)

  - This package provides a new combinatorial data structure allowing to
    describe any orientable subdivided object whatever its dimension. It
    describes all cells of the subdivision and all the incidence and adjacency
    relations between these cells. For example it allows to describe a 3D
    object subdivided in vertices, edges, faces and volumes. This data
    structure can be seen as the generalization in dD of the halfedge data
    structure.


* 3D Convex Hull (major performance improvement)

  - The quickhull implementation of CGAL (CGAL::convex_hull_3) has been worked
    out to provide very better performances.

  - The function CGAL::convex_hull_3 no longer computes the plane equations of
    the facets of the output polyhedron. However an example is provided to show
    how to compute them easily.

  - A global function convex_hull_3_to_polyhedron_3 is now provided to extract
    the convex hull of a 3D points set from a triangulation of these points.


* dD Spatial Searching (major new feature added)

  - A traits-class and distance adapter that together with a point property
    map, allow to make nearest neighbor queries on keys instead of points have
    been added.

  - Few bug fixes in the documentation have revealed some inconsistencies that
    have been corrected. Two traits class concept are now documented
    (RangeSearchTraits and SearchTraits). Most other changes concerns only
    classes documented as advanced. One issue that user can encounter is due to
    an additional requirement on the nested class
    Construct_cartesian_const_iterator_d defined in the concept SearchTraits
    that must provide a nested type result_type.


* Spatial Sorting (major new feature added)

  - General dimension is now supported.

  - Hilbert sorting admits now two policies: splitting at median or at middle
    (see user manual).

  - Using a property map, sorting on keys instead of points is now easier


* dD Kernel

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


* 2D Arrangements

  - A new geometry-traits class that handles rational arcs, namely
    Arr_rational_function_traits_2, has been introduced. It replaced an old
    traits class, which handled the same family of curves, but it was less
    efficient. The new traits exploits CGAL algebraic kernels and polynomials,
    which were not available at the time the old traits class was developed.

  - A new geometry traits concept called ArrangementOpenBoundaryTraits_2 has
    been introduced. A model of this concept supports curves that approach the
    open boundary of an iso-rectangular area called parameter space, which can
    be unbounded or bounded. The general code of the package, however, supports
    only the unbounded parameter space. We intend to enhance the general code
    to support also bounded parameter spaces in a future release.

  - The deprecated member function is_at_infinity() of Arrangement_2::Vertex
    has been removed. It has been previously replaced new function
    is_at_open_boundary().

  - The tags in the geometry traits that indicate the type of boundary of the
    embedding surface were replaced by the following new tags:
             Left_side_category
             Bottom_side_category
             Top_side_category
             Right_side_category
    It is still possible not to indicate the tags at all. Default values are
    assumed. This however will produce warning messages, and should be avoided.


-------------------------------- Release 3.8 --------------------------------

Release date: April 2011

CGAL 3.8 offers the following improvements and new functionality :


* General

  - Boost version 1.39 at least is now required.

  - Initial support for the LLVM Clang compiler (prereleases of version 2.9).

  - Full support for the options -strict-ansi of the Intel Compiler 11, and -
    ansi of the GNU g++ compiler.

  - Adding a concept of ranges. In the following releases, it will be the way
    to provide a set of objects (vs. a couple of iterators).

  - Fix a memory leak in CORE polynomials.

  - Various fixes in the manual.


* 3D Mesh Generation (major new feature added)

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


* 2D Triangulations (major new feature added)

  - Add a way to efficiently insert a range of points with information into a
    2D Delaunay and regular triangulation.

  - Add member function mirror_edge taking an edge as parameter.

  - Fix an infinite loop in constrained triangulation.


* 3D Triangulations (major new feature added)

  - Add a way to efficiently insert a range of points with information into a
    3D Delaunay and regular triangulation.

  - Add a member function to remove a cluster of points from a Delaunay or
    regular triangulation.

  - function vertices_in_conflict is renamed vertices_on_conflict_zone_boundary
    for Delaunay and regular triangulation. Function
    vertices_inside_conflict_zone is added to regular triangulation.

  - Structural filtering is now internally used in locate function of Delaunay
    and regular triangulation. It improves average construction time by 20%.

  - Added demo.


* 3D Alpha Shapes (major new feature added)

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


* AABB tree

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


* 2D and 3D Kernel

  - Better handling of 2D points with elevation (3D points projected onto
    trivial planes). More general traits classes (Projection_traits_xy_3,
    Projection_traits_yz_3,Projection_traits_yz_3) are provided to work with
    triangulations, algorithms on polygons, alpha-shapes, convex hull
    algorithm... Usage of former equivalent traits classes in different
    packages is now deprecated.

  - Exact_predicates_exact_constructions_kernel now better use the static
    filters which leads to performance improvements.

  - Add an overload for the global function angle, taking three 3D points.

  - In the 2D and 3D kernel concept, the constant Boolean
    Has_filtered_predicates is now deprecated. It is now required to use
    Has_filtered_predicates_tag (being either Tag_true or Tag_false).

  - Compare_distance_2 and Compare_distance_3 provide additional operators for
    3 and 4 elements.

  - Add intersection test and intersection computation capabilities between an
    object of type Ray_3 and either an object of type Line_3, Segment_3 or
    Ray_3.

  - Improve intersection test performance between an object of type Bbox_3 and
    an object of type Plane_3 or Triangle_3 by avoiding arithmetic filter
    failures.


* 2D Envelope

  - Env_default_diagram_1 is deprecated, Envelope_diagram_1 should be used
    instead.


* 3D Envelope

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


* dD Kernel

  - Add functor Compute_coordinate_d to Kernel_d concept.


* Geometric Object Generators

  - CGAL::Random uses boost::rand48 instead of std::rand.

  - Adding to CGAL::Random a way to generate random integers.

  - Adding generators for dD points.


* Algebraic Foundations

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


* Bounding Volumes

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


* Triangulated Surface Mesh Simplification

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


* 3D Boolean Operations on Nef Polyhedra

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


* 2D Arrangements

  - Fix a bug in the method insert_at_vertices of the Arrangement_2 class.

  - Fix several bugs in the traits class Arr_Bezier_curve_traits_2 for
    arrangement of Bezier curves.


* 2D Minkowski Sums

  - A bug in the convolution method was fixed.


-------------------------------- Release 3.7 --------------------------------

Release date: October 2010

CGAL 3.7 offers the following improvements and new functionality :


* General

  - The configuration of CGAL libraries now requires CMake>=2.6.

  - Changes in the set of supported platforms:

      - GNU g++ 4.5 supported (with or without the compilation option -
        std=c++0x).

      - Initial support for the option -strict-ansi of the Intel Compiler 11.
        The CGAL libraries compile with that option, and most CGAL headers have
        been fixed. The packages "3D Boolean Operations on Nef Polyhedra"
        (Nef_3), "Convex Decomposition of Polyhedra" (Convex_decomposition_3),
        and "3D Minkowski Sum of Polyhedra" (Minkowski_sum_3) are known to
        still fail to compile with that compiler flag.

      - The Microsoft Windows Visual C++ compiler 2010 (VC10), that was
        experimentally supported by CGAL-3.6.1, is now fully supported. Note
        that CMake>=2.8.2 is required for that support.

      - The Microsoft Windows Visual C++ compiler 2005 (VC8) is no longer
        supported by the CGAL project since CGAL-3.7.

      - With Microsoft Windows Visual C++ (VC9 and VC10), the optional
        dependencies Gmp, Mpfr, Blas, Lapack, Taucs no longer use Boost-style
        name mangling. Only one variant is now provided by the CGAL Windows
        installer (release, with dynamic runtime).


  - Some demos now require a version of Qt4 >= 4.3.

  - CGAL_PDB is no longer provided with CGAL. An alternative solution for
    people interested in reading PDB files is to use ESBTL (http://
    esbtl.sourceforge.net/).

  - Fix issues of the CGAL wrappers around the CORE library, on 64 bits
    platforms.


* Arithmetic and Algebra

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


* Arrangements

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


* 2D Triangulations

  - The Delaunay and regular 2D triangulations now use a symbolic perturbation
    to choose a particular triangulation in co-circular cases.

  - The return type of the template member function insert(It beg, It end),
    taking an iterator range of points, has been changed from int to std::
    ptrdiff_t.

  - Classes Triangulation_euclidean_traits_xy_3,
    Triangulation_euclidean_traits_yz_3 and Triangulation_euclidean_traits_xz_3
    are now model of the concept ConstrainedTriangulationTraits_2. They can be
    used with and without intersection of constraints.

  - 2D Delaunay and basic triangulations now provide vertex relocation by the
    mean of these two new methods: move and move_if_no_collision. The methods
    are also available for the hierarchy (Triangulation_hierarchy_2).


* 3D Triangulations

  - The return type of the template member function insert(It beg, It end),
    taking an iterator range of points, has been changed from int to std::
    ptrdiff_t.

  - 3D Delaunay triangulations now provide vertex relocation by the mean of
    these two new methods: move and move_if_no_collision. This works in both
    Compact_policy and Fast_policy.


* 2D and 3D Alpha Shapes

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


* 2D Mesh Generation

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


* 3D Mesh Generation

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

  - A demo program is now available.


* Surface Reconstruction from Point Sets

  - Improved performance and minor bug fix.


* 2D Range and Neighbor Search

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


-------------------------------- Release 3.6.1 --------------------------------

Release date: June 2010

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


* General

  - Fix compilation errors with recent Boost versions (since 1.40).

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


* Polynomial

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


* Polyhedron

  - Fix a compilation errors in demo/Polyhedron/:

  - issue with the location of qglobal.h of Qt4 on MacOS X,

  - missing texture.cpp, if TAUCS is used,

  - Fix the location of built plugins of demo/Polyhedron/, when CGAL is
    configured with WITH_demos=ON


* 3D Periodic Triangulations

  - Fixed bug in the triangulation hierarchy for periodic triangulations.


* 2D Mesh Generation

  - Fix a bug that lead to precondition violation.

  - Improve the user manual about the member function is_in_domain() of the
    Face type.

  - The 2D meshing process is now deterministic (sorting of bad faces no longer
    relies on pointers comparisons).


* 3D Mesh Generation

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


* Spatial Searching

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


* IO Streams

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


* Triangulation_2

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


-------------------------------- Release 3.6 --------------------------------

Release date: March 2010

CGAL 3.6 offers the following improvements and new functionality :


* General

  - Boost version 1.34.1 at least is now required.


* Arithmetic and Algebra

 ** Algebraic Kernel (new package)

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


 ** Number Types

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


* Geometry Kernels

 ** 2D and 3D Geometry Kernel

  - Add new do_intersect() and intersection() overloads:

      - do_intersect(Bbox_3, Bbox_3/Line_3/Ray_3/Segment_3)

      - intersection(Triangle_3, Line_3/Ray_3/Segment_3)



* Polygons

 ** 2D Regularized Boolean Set-Operations

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


* Arrangement

 ** 2D Arrangements

  - Fixed passing a (const) traits object to the constructor of Arrangement_2.

  - Introduced Arrangement_2::fictitious_face(), which returns the fictitious
    face in case of an unbounded arrangement.

  - Fixed a bug in Bezier-curve handling.

  - Added (back) iterator, number_of_holes(), holes_begin(), and holes_end() to
    the default DCEL for backward compatibility.

  - Added (simple) versions of the free overlay() function. It employs the
    default overlay-traits, which practically does nothing.


* Polyhedron

  - Fix a compilation errors in demo/Polyhedron/:

      - issue with the location of qglobal.h of Qt4 on MacOS X,

      - missing texture.cpp, if TAUCS is used,


  - Fix the location of built plugins of demo/Polyhedron/, when CGAL is
    configured with WITH_demos=ON

  - Fix a bug in test_facet function of the incremental builder: the function
    did not test if while a new facet makes a vertex manifold, no other facet
    incident to that vertex breaks the manifold property.


* Triangulations and Delaunay Triangulations

 ** 2D/3D Regular Triangulations

  - Weighted_point now has a constructor from Cartesian coordinates.


 ** 3D Triangulations

  - Regular_triangulation_3 : semi-static floating-point filters are now used
    in its predicates, which can speed up its construction by a factor of about
    3 when Exact_predicates_inexact_constructions_kernel is used.

  - The class Regular_triangulation_filtered_traits_3 is deprecated, the class
    Regular_triangulation_euclidean_traits_3 must be used instead. The
    predicates of that traits will be filtered if the kernel given as template
    parameter of that traits is itself a filtered kernel.

  - Triangulation_hierarchy_3 is now deprecated, and replaced by a simpler
    CGAL::Fast_location policy template parameter of Delaunay_triangulation_3.

  - The old version of remove() (enabled with CGAL_DELAUNAY_3_OLD_REMOVE) has
    been deleted.


 ** 3D Periodic Triangulations

  - New demo: 3D periodic Lloyd algorithm.

  - New functionality for Voronoi diagrams: dual of an edge and of a vertex,
    volume and centroid of the dual of a vertex.

  - The package can now be used with the 3D Alpha Shapes package to compute
    periodic alpha shapes.


 ** 3D Alpha shapes

  - The class Weighted_alpha_shape_euclidean_traits_3 is deprecated, the class
    Regular_triangulation_euclidean_traits_3 must be used instead.

  - The package can now be used together with the 3D Periodic Triangulation
    package to compute periodic alpha shapes.


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

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


* Mesh Generation

 ** 2D Mesh Generation

  - The 2D mesh generator can now be used with a constrained Delaunay
    triangulation with constraints hierarchy
    (Constrained_triangulation_plus_2).

  - In some cases (refinement of a constrained edge that is on the convex
    hull), the 2D mesh generator from CGAL-3.4 and CGAL-3.5 could create
    invalid triangulations. This bug is now fixed.


 ** 3D Mesh Generation

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


* Support library

 ** CGAL ipelets

  - Add support for version 7 of Ipe.


-------------------------------- Release 3.5.1 --------------------------------

Release date: December 2009

This is a bug fix release.


* Documentation

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

  - Fixes to the bibliographic references.


* Windows installer

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


* Bug fixes in the following CGAL packages

 ** AABB tree

  - Fix a linker issue in do_intersect(Bbox_3,Bbox_3).

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


 ** 3D Mesh Generation

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


-------------------------------- Release 3.5 --------------------------------

Release date: October 2009

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

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


* General

  - Additional supported platforms:

      - GNU g++ 4.4 supported.

      - Intel Compiler 11 supported on Linux


  - Fixed ABI incompatibilities when mixing CGAL and Boost Program Options on
    Windows/Visual C++ (the compilation flag -D_SECURE_SCL=0 is not longer use
    in Debug mode).


* Geometry Kernels

 ** 3D Spherical Geometry Kernel

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


* Polygons

 ** 2D Regularized Boolean Set-Operations

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


 ** 2D Straight Skeleton and Polygon Offsetting

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


* Arrangements

 ** 2D Arrangements

  - The member function is_at_infinity() of Arrangement_2::Vertex was replaced
    by the new function is_at_open_boundary(). The former is deprecated. While
    still supported in version 3.5, It will not be supported in future
    releases. The member functions boundary_type_in_x() and boundary_type_in_y
    () were permanently replaced by the functions parameter_space_in_x() and
    parameter_space_in_y(), respectively. The 2 new functions return an
    enumeration of a new type, namely Arr_parameter_space.

  - The tags in the geometry traits that indicate the type of boundary of the
    embedding surface were replaced by the following new tags:
    Arr_left_side_tag Arr_bottom_side_tag Arr_top_side_tag Arr_right_side_tag
    In addition, the code was change, and now it is possible not to indicate
    the tags at all. Default values are assumed. This however will produce
    warning messages, and should be avoided.

  - All operations of the geometry traits-class were made 'const'. This change
    was reflected in the code of this package and all other packages that are
    based on it. Traits classes that maintain state, should declare the data
    members that store the state as mutable.


 ** Envelopes of Surfaces in 3D

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


* Triangulations and Delaunay Triangulations

 ** 3D Periodic Triangulations (new package)

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


* Mesh Generation

 ** Surface Reconstruction from Point Sets (new package)

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


 ** 3D Mesh Generation (new package)

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


* Geometry Processing

 ** Triangulated Surface Mesh Simplification

  - BREAKING API change in the passing of the visitor object.

  - Fixed a bug in the link_condition test

  - Added a geometric test to avoid folding of facets

  - Fixed a bug in the handling of overflow in the LindstromTurk computations

  - Updated the manual to account for the new visitor interface


 ** Point Set Processing (new package)

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


* Spatial Searching and Sorting

 ** AABB tree (new package)

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


* Support Library

 ** CGAL_ipelets (new package):

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


-------------------------------- Release 3.4 --------------------------------

Release date: January 2009

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


* General

  - GNU g++ 4.3 supported. Support for g++ 3.3 is dropped.

  - Visual 9 supported. Support for Visual 7 is dropped.

  - Boost version 1.33 at least is now required.

  - CGAL now depends on Boost.Threads, which implies to link against a compiled
    part of Boost.

  - The new macro CGAL_NO_DEPRECATED_CODE can be defined to disable deprecated
    code, helping users discover if they rely on code that may be removed in
    subsequent releases.

  - Assertion behaviour: It is not possible anymore to set the CONTINUE mode
    for assertion failures. Functions that allow to change the assertion
    behaviour are now declared in <CGAL/assertions_behaviour.h>.

  - Qt3 based demos are still there but the documentation has been removed as
    the CGAL::Qt_Widget will be deprecated.

  - Qt4 based demos use the Qt GraphicsView framework and the libQGLViewer.


* Installation

  - install_cgal has been replaced by CMake.


* Polynomial (new package)

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


* Modular Arithmetic (new package)

  - This package provides arithmetic over finite fields.


* Number Types

  - the counter Interval_nt::number_of_failures() has been removed, replaced by
    a profiling counter enabled with CGAL_PROFILE.

  - Fix of a bug in CORE/Expr.h; as a consequence, the arrangement demo works
    properly when handling arrangements of conics, for example, when defining
    an arc with 5 points.


* 3D Spherical Geometry Kernel (new package)

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


* Linear Kernel

  - We recommend that you use the object_cast() function instead of assign() to
    extract an object from a CGAL::Object, for efficiency reasons.

  - The Kernel archetypes provided by the 2D/3D linear kernel have been
    removed.

  - The deprecated linear kernel functors Construct_supporting_line_2 and
    Construct_supporting_line_3 have been removed.

  - Ambiant_dimension and Feature_dimenison have been added to retrieve the
    potentially compile-time dimension of a space or of an object.

  - barycenter() functions have been added.

  - The geometric object Circle_3 as well as predicates and constructions have
    been added to the kernel

  - The missing intersection/do_intersect between Line_3 and Line_3 has been
    added as well.


* 3D Triangulations

  - Removed the deprecated functions Cell:mirror_index() and Cell::
    mirror_vertex().

  - Derecursification of two functions that in some cases lead to stack
    overflows


* 3D Nef Polyhedron

  - n-ary union/intersection

  - intersection with halfspace under standard kernel

  - constructor for polylines


* CGAL and the Qt4 GraphicsView (new package)

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


* STL Extensions:

  - The functor adaptors for argument binding and composition (bind_*, compose,
    compose_shared, swap_*, negate, along with the helper functions set_arity_*
    and Arity class and Arity_tag typedefs) which were provided by <CGAL/
    functional.h> have been removed. Please use the better boost::bind mecanism
    instead. The concept AdaptableFunctor has been changed accordingly such
    that only a nested result_type is required.

  - The accessory classes Twotuple, Threetuple, Fourtuple and Sixtuple are also
    deprecated (use CGAL::array instead).

  - CGAL::Triple and CGAL::Quadruple are in the process of being replaced by
    boost::tuple. As a first step, we strongly recommend that you replace the
    direct access to the data members (.first, .second, .third, .fourth), by
    the get<i>() member function; and replace the make_triple and
    make_quadruple maker functions by make_tuple.
    This way, in a further release, we will be able to switch to boost::tuple
    more easily.

  - The class CGAL::Uncertain<> has been documented. It is typically used to
    report uncertain results for predicates using interval arithmetic, and
    other filtering techniques.


* 2D Arrangements

  - Changed the name of the arrangement package from Arrangement_2 to
    Arrangement_on_surface_2 to reflect the potential capabilities of the
    package to construct and maintain arrangements induced by curves embedded
    on two dimensional surfaces in three space. Most of these capabilities will
    become available only in future releases though.

  - Enhanced the geometry traits concept to handle arrangements embedded on
    surfaces. Each geometry-traits class must now define the
    'Boundary_category' tag.

  - Fixed a bug in Arr_polyline_traits_2.h, where the operator that compares
    two curves failed to evaluate the correct result (true) when the curves are
    different, but their graphs are identical.

  - Permanently removed IO/Arr_postscript_file_stream.h and IO/
    Polyline_2_postscript_file_stream.h, as they depend on obsolete features
    and LEDA.

  - Fixed several bugs in the arrangement demo and enhanced it. e.g., fixed
    background color change, allowed vertex coloring , enabled "smart" color
    selection, etc.

  - Enhanced the arrangement demo with new features, such as allowing the
    abortion of the merge function (de-select), updated the how-to description,
    etc.

  - Replace the functions CGAL::insert_curve(), CGAL::insert_curves(), CGAL::
    insert_x_monotone_curve(), and CGAL::insert_x_monotone_curves() with a
    single overloaded function CGAL::insert(). The former 4 functions are now
    deprecated, and may no longer be supported in future releases.


* Envelopes of Surfaces in 3D

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


* 2D Regularized Boolean Set-Operations

  - Fixed a bug in connect_holes() that caused failures when connecting holes
    touching the outer boundary.

  - Fixed the concept GeneralPolygonSetTraits_2. Introduced two new concepts
    GpsTraitsGeneralPolygon_2 and GpsTraitsGeneralPolygonWithHoles_2. Fixed the
    definition of the two nested required types Polygon_2 and
    Polygon_with_holes_2 of the GeneralPolygonSetTraits_2 concept. They must
    model now the two new concepts above.

  - Added a default template parameter to 'General_polygon_set_2' to allow
    users to pass their specialized DCEL used to instantiate the underlying
    arrangement.

  - Enhanced the BOP demo to use multiple windows.


* 2D Minkowski Sums

  - Fixed a few bugs in the approximate offset function, making it robust to
    highly degenerate inputs.

  - Fixed a bug in the exact Minkowski sum computation when processing
    degenerate inputs that induce overlapping of contiguous segments in the
    convolution cycles.

  - Optimized the approximate offset function (reduced time consumption up to a
    factor of 2 in some cases).

  - Added functionality to compute the offset (or to approximate the offset) of
    a Polygon_with_holes_2 (and not just of a Polygon_2).

  - Added the functionality to compute (or to approximate) the inner offset of
    a polygon.


-------------------------------- Release 3.3.1 --------------------------------

Release date: August 2007

This is a bug fix release.


* General

  - Intel C++ 9 was wrongly recognized as unsupported by install_cgal.

  - Added autolink (for Visual C++) for the CGALImageIO and CGALPDB libraries.

  - Fixed bug in Memory_sizer when using more than 4GB of memory (64bit).


* Number Types

  - Fixed bug in FPU rounding mode macros (affected only the alpha
    architecture).

  - Fixed bug in MP_Float constructor from double for some particular values.

  - Fixed bug in to_double(Lazy_exact_nt) sometimes returning NaN.


* Kernel

  - Fixed forgotten derivation in Circular_kernel_2::Has_on_2

  - Added some missing functions in Bbox_3 compared to Bbox_2.


* Skin Surface Meshing

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


* Arrangements

  - Fixed a bug in the Arrangement_2 package in dual arrangement representation
    for Boost graphs when reporting all halfedges of a face.

  - Fixed a bug in the Arrangement sweep-line when using a specific polyline
    configuration.

  - Fixed bug in Arrangement_2 in walk along a line point location for
    unbounded curves.

  - Fixed bug in aggregated insertion to Arrangement_2.

  - Fixed bug in Arrangment_2 class when inserting an unbounded curve from an
    existing vertex.

  - Fixed bug when dealing with a degenerate conic arc in Arr_conic_traits_2 of
    the Arrangment package, meaning a line segment which is part of a
    degenerate parabola/hyperbola.

  - Fixed bug in the Bezier traits-class: properly handle line segments.
    properly handle comparison near a vertical tangency.


* 2D Polygon

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


* 2D Triangulations

  - Fixed bug in Regular_triangulation_2.


* 3D Triangulations

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

  - Added missing operator->() to Facet_circulator.


* Interpolation

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


* 3D Boolean Operations on Nef Polyhedra

  - Fixed bug in construction of Nef_polyhedron_3 from off-file. Now, always
    the inner volume is selected.

  - Fixed bug in conversion from Nef_polyhedron_3 to Polyhedron_3. Polyhedron_3
    was not cleared at the beginning.

  - Fixed bug in Nef_polyhedron_3 in update of indexes for construction of
    external structure.


* Third Party Libraries Shipped with CGAL

  - TAUCS supports now 64 bits platforms.

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


-------------------------------- Release 3.3 --------------------------------

Release date: May 2007

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

Additional supported platforms

  - GNU g++ 4.1 and 4.2

  - Intel C++ compiler 9

  - Microsoft Visual C++ compiler 8.0


The following platforms are no longer supported:

  - Intel 8


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

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


* Installation

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

  - On all platforms but Windows shared and static versions of the libraries
    are generated


* Manuals

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


* Algebraic Foundations

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

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



* Kernels

  - 2D Circular Kernel
    Efficiency improved through geometric filtering of predicates, introduced
    with the filtered kernel Filtered_bbox_circular_kernel_2<.>, and also
    chosen for the predefined kernel Exact_circular_kernel_2.

  - Linear Kernel
    Exact_predicates_exact_constructions_kernel memory and run-time
    improvements through usage of lazy geometric constructions instead of lazy
    arithmetic.



* Data Structures and Algorithms

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

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

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

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

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

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

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

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

  - 2D Arrangements

      - Added support for unbounded curves.

      - Added a traits class that supports bounded and unbounded linear
        objects, namely lines, rays and line segments.

      - Added traits classes that handle circular arcs based on the circular
        kernel.

      - Added a traits class that supports Bezier curves.

      - Enhanced the traits class that supports rational functions to handle
        unbounded (as well as bounded) arcs

      - Added a free function called decompose() that produces the symbolic
        vertical decomposition of a given arrangement, performing a batched
        vertical ray-shooting query from all arrangement vertices.

      - Fixed a memory leak in the sweep-line code.

      - Fixed a bug in computing the minor axis of non-degenerate hyperbolas.


  - Boolean Set Operations

      - Added the DCEL as a default template parameter to the
        General_polygon_set_2 and Polygon_set_2 classes. This allows users to
        extend the DCEL of the underlying arrangement.

      - Added a function template called connect_holes() that connects the
        holes in a given polygon with holes, turning it into a sequence of
        points, where the holes are connceted to the outer boundary using zero-
        width passages.

      - Added a non-const function member to General_polygon_set_2 that obtains
        the underlying arrangement.


  - 2D and 3D Triangulations

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


  - Optimal Distances

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


  - Bounding Volumes

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




* Support Library

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

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

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


-------------------------------- Release 3.2.1 --------------------------------

Release date: July 2006

This is a bug fix release


* Number Types

  - Fix MP_Float constructor which crashed for some values.


* Kernel

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


* Arrangement

  - Derived the Arr_segment_traits_2 Arrangement_2 traits class from the
    parameterized Kernel. This allows the use of this traits class in an
    extended range of applications that require kernel objects and operations
    on these objects beyond the ones required by the Arrangement_2 class
    itself.

  - Fixed a compilation bug in the code that handles overlay of arrangements
    instantiated with different DCEL classes.

  - Fixed a couple of bugs in the implementation of the Trapezoidal RIC point-
    location strategy


* Triangulation, Alpha Shapes

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


* Surface Mesher

  - Fixed a bug in iterators of the class template
    Surface_mesh_complex_2_in_triangulation_3


* Surface Mesh Parametrisation

  - Updated the precompiled taucs lib


* Kinetic Data Structures

  - Fixed problems caused by old versions of gcc being confused by operator!
    and operator int()

  - Added point removal support to the Active_objects_vector


-------------------------------- Release 3.2 --------------------------------

Release date: May 2006

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

The following platforms are no longer supported:

  - SunPro CC versions 5.4 and 5.5 on Solaris

  - SGI Mips Pro


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


* Installation

  - The install tool tries to find third party libraries at "standard"
    locations.

  - Installers for Apple, Windows, and rpms.


* Manuals

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


* Kernels

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



* Data Structures and Algorithms

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

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

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

  - 3D Surface Mesher (new package)
    This package provides functions to generate surface meshes that interpolate
    smooth surfaces. The meshing algorithm is based on Delaunay refinement and
    provides some guarantees on the resulting mesh: the user is able to control
    the size and shape of the mesh elements and the accuracy of the surface
    approximation. There is no restriction on the topology and number of
    components of input surfaces. The surface mesher may also be used for non
    smooth surfaces but without guarantee.
    Currently, implementations are provided for implicit surfaces described as
    the zero level set of some function and surfaces described as a gray level
    set in a three-dimensional image.


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

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

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

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

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

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

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

  - 2D Arrangement (major revision)
    This package can be used to construct, maintain, alter, and display
    arrangements in the plane. Once an arrangement is constructed, the package
    can be used to obtain results of various queries on the arrangement, such
    as point location. The package also includes generic implementations of two
    algorithmic frameworks, that are, computing the zone of an arrangement, and
    line-sweeping the plane, the arrangements is embedded on.
    Arrangements and arrangement components can also be extended to store
    additional data. An important extension stores the construction history of
    the arrangement, such that it is possible to obtain the originating curve
    of an arrangement subcurve.


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

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



-------------------------------- Release 3.1 --------------------------------

Release date: December 2004

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

Additional supported platforms:

  - MS Visual C++, version 7.3. and 8.0

  - Intel 8.0

  - SunPro CC versions 5.4 and 5.5 on Solaris

  - GNU g++ versions 3.4 on Linux, Solaris, Irix, cygwin, FreeBSD, and MacOS X

  - Darwin (MacOS X) and IA64/Linux support.


The following platforms are no longer supported:

  - MS Visual C++, version 7.0


The following functionality has been added or changed:



* All

  - The CORE 1.7 library for exact real arithmetic.

  - Updated GMP to 4.1.3.

  - Added Mpfr a library for multiple-precision floating-point computations
    with exact rounding.

  - Added Boost 1.32.0 (only include files).


* Installation

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


* Manuals

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

  - Improved layout.


* Kernels

  - Improved efficiency of filtered kernels.

  - More predicates and constructions.


* Basic Library

  - 2D Segment Voronoi Diagram (new package)
    A data structure for Voronoi diagrams of segments in the plane under the
    Euclidean metric. The Voronoi edges are arcs of straight lines and
    parabolas. The algorithm provided in this package is incremental.

  - 2D Conforming Triangulations and Meshes (new package)
    An implementation of Shewchuk's algorithm to construct conforming
    triangulations and 2D meshes.

  - 3D Boolean Operations on Nef Polyhedra (new package)
    A new class (Nef_polyhedron_3) representing 3D Nef polyhedra, a boundary
    representation for cell-complexes bounded by halfspaces that supports
    boolean operations and topological operations in full generality including
    unbounded cells, mixed dimensional cells (e.g., isolated vertices and
    antennas). Nef polyhedra distinguish between open and closed sets and can
    represent non-manifold geometry.

  - 2D and Surface Function Interpolation (new package)
    This package implements different methods for scattered data interpolation:
    Given measures of a function on a set of discrete data points, the task is
    to interpolate this function on an arbitrary query point. The package
    further offers functions for natural neighbor interpolation.

  - Planar Nef polyhedra embedded on the sphere (new package)
    A new class (Nef_polyhedron_S2) designed and supported mainly to represent
    sphere neighborhoods around vertices of the three- dimensional Nef
    polyhedra.

  - Box_intersection_d (new package)
    A new efficient algorithm for finding all intersecting pairs for large
    numbers of iso-oriented boxes, i.e., typically these will be bounding boxes
    of more complicated geometries. Useful for (self-) intersection tests of
    surfaces etc.

  - 2D Snap Rounding (new package)
    Snap Rounding is a well known method for converting arbitrary-precision
    arrangements of segments into a fixed-precision representation. In the
    study of robust geometric computing, it can be classified as a finite
    precision approximation technique. Iterated Snap Roundingis a modification
    of Snap Rounding in which each vertex is at least half-the-width-of-a-pixel
    away from any non-incident edge. This package supports both methods.

  - 3D Triangulations

      - Triangulation_3: added operator==(),removed push_back() and
        copy_triangulation().

      - Delaunay_3 : added nearest_vertex(), move_point(), vertices_in_conflict
        ().

      - Regular_3 : added filtered traits class, and nearest_power_vertex().


  - Planar_map and Arrangement_2

      - The interface of the two traits functions that compute the intersection
        of two given curves changed. The functions
        nearest_intersection_to_right() and nearest_intersection_to_left()
        return an object of type CGAL::Object that represents either an empty
        intersection, a point, or an overlapping subcurve.

      - Requirements to define two binary tags were added to the traits concept
        of the Planar_map as follows: Has_left_category - indicates whether the
        functions curves_compare_y_at_x_left() and nearest_intersection_to_left
        () are implemented in the traits model. Has_reflect_category -
        indicates whether the functions point_reflect_in_x_and_y() and
        curve_reflect_in_x_and_y() are implemented in the traits model. They
        can be used as an alternative to the two function in the previous item.

      - A new constructor of the Segment_cached_2 type that represents a
        segment in the Arr_segment_cached_traits_2 traits class was introduced.
        The new constructor accepts the segment endpoints as well as the
        coefficients of the underlying line.

      - A new version of the conic-arc traits, based on CORE version 1.7 was
        introduced. This new traits class makes use of CORE's rootOf() operator
        to compute the intersection points in the arrangement, making its code
        much simpler and more elegant than the previous version. In addition,
        new constructors for conic arcs are provided. The new traits class
        usually performs about 30% faster than the version included in CGAL 3.0

      - The traits class that handles continuous piecewise linear curves,
        namely Arr_polyline_traits_2, was rewritten. The new class is
        parametrized with a traits class that handles segments, say
        Segment_traits. The polyline curve defined within the
        Arr_polyline_traits_2 class is implemented as a vector of segments of
        type Segment_traits::Curve_2.

      - A meta traits class, namely Arr_curve_data_traits_2, that extends the
        curve type of the planar-map with arbitrary additional data was
        introduced. It should be instantiated with a regular traits-class and a
        class that contains all extraneous data associated with a curve.

      - The class that represents the trapezoidal-decomposition point location
        strategy was renamed to Pm_trapezoid_ric_point_location.

      - The Arrangement demo was rewritten. It covers many more features, has a
        much better graphical user interface, and comes with online
        documentation.

      - Few bugs in the sweep-line module related to overlapping vertical
        segments were fixed. This module is used by the aggregate insert method
        that inserts a collection of curves at once.


  - Triangulation_2

      - added a filtered trait class in the regular triangulation

      - added split and join operations in the triangulation data structure
        class


  - Alpha_shapes_3

      - major changes in the implementation of the class Alpha_shapes_3.

      - New implementation results in a true GENERAL mode allowing null and
        negative alpha-values. It also fixed the edges classification bug and
        introduces a classification of vertices.


  - Min_ellipse_2

      - made access to approximate double representation public

      - fixed bugs in conversion to double representation

      - added is_circle() method

      - minor performance improvements


  - Min_sphere_of_spheres_d:

      - The models Min_sphere_of_spheres_d_traits_2<K,FT,UseSqrt,Algorithm>,
        Min_sphere_of_spheres_d_traits_3<K,FT,UseSqrt,Algorithm>, and
        Min_sphere_of_spheres_d_traits_d<K,FT,Dim,UseSqrt,Algorithm> of concept
        MinSphereOfSpheresTraits now represent a sphere as a std::
        pair<Point,Radius> (and not any more as a CGAL::
        Weighted_point<Point,Weight>)

      - Internal code cleanup; in particular, implementation details don't
        pollute the namespace CGAL anymore


  - Polyhedron_3

      - New Tutorial on CGAL Polyhedron for Subdivision Algorithms with
        interactive demo viewer in source code available.

      - Added example program for efficient self-intersection test. - Added
        small helper functions, such as vertex_degree, facet_degree, edge_flip,
        and is_closed.


  - Apollonius Graph (Voronoi of Circles)

      - Reduced memory requirements by approximately a factor of two.



-------------------------------- Release 3.0.1 --------------------------------

Release date: February 2004

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


* Polyhedral Surface

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


* Planar_map

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


* 2D Triangulation

  - added missing figure in html doc

  - in Line_face_circulator_2.h:
    Fixed changes made to support handles with a typedef to iterator. The fix
    concerns operator== and !=.


* Alpha_shapes_3

  - fixed classify member function for edges.


* Number types

  - Lazy_exact_nt:

      - added the possibility to select the relative precision of to_double()
        (by default 1e-5). This should fix reports that some circumcenters
        computations have poor coordinates, e.g. nan).

      - when exact computation is triggered, the interval is recomputed, this
        should speed up some kinds of computations.


  - to_interval(Quotient<MP_Float>): avoid spurious overflows.


* Kernel

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


-------------------------------- Release 3.0 --------------------------------

Release date: October 2003

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

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

Additional supported platforms:

  - MS Visual C++, version 7.1.

  - SunPro CC versions 5.4 and 5.5 on Solaris

  - GNU g++ versions 3.2 and 3.3 on Linux, Solaris, Irix, cygwin, and FreeBSD.

  - MipsPRO CC 7.30 and 7.40 with both the n32 and n64 ABIs.


The following platforms are no longer supported:

  - MS Visual C++, version 6.

  - GNU g++ 2.95.2 (2.95.3 is still supported)

  - Kai C++ and Borland C++, all versions


The following functionality has been added or changed:

All

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



* Kernels

  - 3 typedefs have been added to ease the choice of a robust and fast kernel:

      - Exact_predicates_inexact_constructions_kernel

      - Exact_predicates_exact_constructions_kernel

      - Exact_predicates_exact_constructions_kernel_with_sqrt


  - Progress has been made towards the complete adaptability and extensibility
    of our kernels.

  - New faster Triangle_3 intersection test routines.
    (see Erratum)

  - Added a Kernel concept archetype to check that generic algorithms don't use
    more functionality than they should.

  - A few more miscellaneous functions.


* Basic Library

  - 2D Apollonius Graph (new package)
    Algorithms for computing the Apollonius graph in two dimensions. The
    Apollonius graph is the dual of the Apollonius diagram, also known as the
    additively weighted Voronoi diagram. The latter can be thought of as the
    Voronoi diagram of a set of circles under the Euclidean metric, and it is a
    generalization of the standard Voronoi diagram for points. The algorithms
    provided are dynamic.

  - dD Min Sphere of Spheres (new package)
    Algorithms to compute the smallest enclosing sphere of a given set of
    spheres in Rd. The package provides an algorithm with maximal expected
    running time O(2O(d) n) and a fast and robust heuristic (for dimension less
    than 30).

  - Spatial Searching (new package)
    Provides exact and approximate distance browsing in a set of points in d-
    dimensional space using implementations of algorithms supporting:

      - both nearest and furthest neighbor searching

      - both exact and approximate searching

      - (approximate) range searching

      - (approximate) k-nearest and k-furthest neighbor searching

      - (approximate) incremental nearest and incremental furthest neighbor
        searching

      - query items representing points and spatial objects.


  - Kd-tree
    this package is deprecated, its documentation is removed. It is replaced by
    the Spatial Searching package.

  - Largest_empty_rectangle_2
    Given a set of points P in the plane, the class
    Largest_empty_iso_rectangle_2 is a data structure that maintains an iso-
    rectangle with the largest area among all iso-rectangles that are inside a
    given iso-rectangle bounding box, and that do not contain any point of the
    point set P.

  - 2D Triangulation and 3D Triangulation

      - The classes Triangulation_data_structure_2 (and 3), which implements
        the data structure for 2D triangulation class, now makes use of CGAL::
        Compact_container (see Support Library section below).

      - The triangulation classes use a Rebind mecanism to provide the full
        flexibility on Vertex and Face base classes. This means that it is
        possible for the user to derive its own Face of Vertex base class,
        adding a functionality that makes use of types defined by the
        triangulation data structure like Face_handle or Vertex_handle.

      - New classes Triangulation_vertex_base_with_info_2 (and 3) and
        Triangulation_face_base_with_info_2 (and 3) to make easier the
        customisation of base classes in most cases.


  - 2D Triangulation

      - Regular triangulation provides an easy access to hidden points.

      - The Triangulation_hierarchy_2, which provide an efficient location data
        structure, can now be used with any 2D triangulation class plugged in
        (including Regular triangulations).


  - 3D Triangulation

      - faster vertex removal function in Delaunay_triangulation_3.

      - Delaunay_triangulation_3 is now independent of the order of insertions
        of the points (in case of degenerate cosphericity).

      - Regular_triangulation_3 now hides vertices (and updates itself) when
        inserting a coinciding point with greater weight. This required a new
        predicate.

      - deprecated functions: copy_triangulation(), push_back(),
        set_number_of_vertices().

      - Triangulation_3 now gives non-const access to the data structure.


  - Interval Skip List (new package)
    An interval skip list is a data strucure for finding all intervals that
    contain a point, and for stabbing queries, that is for answering the
    question whether a given point is contained in an interval or not.

  - Planar Maps and Arrangements
    The changes concern mainly the traits classes.
       1. New traits hierarchy and interface: The set of requirements was made
          sound and complete. A couple of requirements were eliminated, few
          others were redefined, and some were renamed. A hierarchy of three
          traits classes for the Planar_map_2, Planar_map_with_intersections_2,
          and Arrangement_2 types was established to include only the necessary
          requirements at each level. It was determined that for the aggregate
          insertion- operation based on a sweep-line algorithm only a subset of
          the requirements is needed. Preconditions were added where
          appropriate to tighten the requirements further.
          The following functions have been renamed:

            - point_is_same() renamed to point_equal()

            - curve_is_same() renamed to curve_equal()

            - curve_is_in_x_range() renamed to point_in_x_range()

            - curve_compare_at_x() renamed to curves_compare_y_at_x()
              Furthermore, a precondition has been added that the reference
              point is in the x-range of both curves.

            - curve_compare_at_x_right() renamed to
              curves_compare_y_at_x_to_right(). Furthermore, a precondition has
              been added that both curves are equal at the reference point and
              defined to its right.

            - curve_compare_at_x_left() renamed to
              curves_compare_y_at_x_to_left(). Furthermore, a precondition has
              been added that both curves are equal at the reference point and
              defined to its right.

            - curve_get_point_status() renamed to curve_compare_y_at_x().
              Furthermore, a precondition has been added that the point is in
              the x-range of the curve. Consequently, the function now returns
              a Comparison_result (instead of a special enum).

            - make_x_monotone() renamed to curve_make_x_monotone() See more
              details below.

            - curve_flip() renamed to curve_opposite()

          The following functions have been removed:

            - curve_is_between_cw()

            - point_to_left()

            - point_to_right()

            - is_x_monotone()

            - point_reflect_in_x_and_y()

            - curve_reflect_in_x_and_y()

            - do_intersect_to_right()

            - do_intersect_to_left()

          Most functions, are required by the PlanarMapTraits_2 concept, except
          for the make_x_monotone(), nearest_intersection_to_right(),
          nearest_intersection_to_left(), curves_overlap() and curve_opposite
          (). PlanarMapWithIntersectionsTraits_2 requires all these functions,
          except curve_opposite(), needed only by the ArrangementTraits_2
          concept.

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

       2. The type X_curve_2 of the PlanarMapWithIntersectionsTraits_2 concept
          was renamed to X_monotone_curve_2, and the distinction between this
          type and the Curve_2 type was made firm. The method is_x_monotone()
          of the PlanarMapWithIntersectionsTraits_2 concept was removed. The
          related method curve_make_x_monotone() is now called for each input
          curve of type Curve_2 when curves are inserted into a
          Planar_map_with_intersections_2 to subdivide the input curve into x-
          monotone sub-curves (and in case the curve is already x-monotone,
          this function is responsible for casting it to an x-monotone curve).
       3. New and improved traits classes:
       4. Conic traits - Arr_conic_traits_2 Support finite segments of
          ellipses, hyperbolas and parabolas, as well as line segments. The
          traits require an exact real number- type, such as leda_real or
          CORE::Expr.
       5. Segment cached traits - Arr_segment_cached_traits_2 This class uses
          an improved representation for segments that helps avoiding cascaded
          computations, thus achieving faster running times. To work properly,
          an exact rational number-type should be used.
       6. Polyline traits - Arr_polyline_traits_2 The polyline traits class has
          been reimplemented to work in a more efficient, generic manner. The
          new class replaces the obsolete Arr_polyline_traits class. It is
          parameterized with a segment traits class.
       7. Hyperbola and segment traits - Arr_hyper_segment_traits_2 Supports
          line segments and segments of canonical hyperbolas. This is the type
          of curves that arise when projecting segments in three-space
          rotationally around a line onto a plane containing the line. Such
          projections are often useful in CAD/CAM problems.
       8. Removed old traits class:

            - The models of the PlanarMapWithIntersectionsTraits_2 concept
              below became obsolete, as the new conic traits, namely
              Arr_conic_traits_2, supports the same functionality and is much
              more efficient.

                - Arr_circles_real_traits

                - Arr_segment_circle_traits


            - The segment traits class and the new polyline traits class were
              reimplemented using standard CGAL-kernel calls. This essentially
              eliminated the corresponding leda traits classes, namely:

                - Pm_leda_segment_traits_2

                - Arr_leda_segment_traits_2

                - Arr_leda_polyline_traits

              With the use of the Leda_rat_kernel new external package the same
              functionality can be achieved with less overhead and more
              efficiency.

       9. Sweep Line

            - The Sweep_line_2 package was reimplemented. As a consequence it
              is much more efficient, its traits is tighter (namely neither the
              two _left nor the reflection functions are required), and its
              interface has changed a bit.
                 1. The following global functions have been removed:

                      - sweep_to_produce_subcurves_2()

                      - sweep_to_produce_points_2()

                      - sweep_to_construct_planar_map_2()

                    Instead, the public methods of the Sweep_line_2 class
                    listed below were introduced:

                      - get_subcurves() - Given a container of curves, this
                        function returns a list of curves that are created by
                        intersecting the input curves.

                      - get_intersection_points() - Given a range of curves,
                        this function returns a list of points that are the
                        intersection points of the curves.

                      - get_intersecting_curves() - Given a range of curves,
                        this function returns an iterator to the beginning of a
                        range that contains the list of curves for each
                        intersection point between any two curves in the
                        specified range.

                 2. It is possible to construct a planar map with intersections
                    (or an arrangement) by inserting a range of curves into an
                    empty map. This will invoke the sweep-line process to
                    construct the map more efficiently.

            - New interface functions to the Planar_map_with_intersections_2
              class. The Planar_map_with_intersections_2 class maintains a
              planar map of input curves that possibly intersect each other and
              are not necessarily x-monotone. If an input curve, or a set of
              input curves, are known to be x-monotone and pairwise disjoint,
              the new functions below can be used to insert them into the map
              efficiently.


  - Polyhedral Surface

      - The old design that was deprecated since CGAL 2.3 has been removed.

      - Class Polyhedron_incremental_builder_3:

          - Renamed local enum ABSOLUTE to ABSOLUTE_INDEXING, and RELATIVE to
            RELATIVE_INDEXING to avoid conflicts with similarly named macros of
            another library.

          - Changed member functions add_vertex(), begin_facet(), and end_facet
            () to return useful handles.

          - Added test_facet() to check facets for validity before adding them.

          - Added vertex( size_t i) to return Vertex_handle for index i.



  - Halfedge Data Structure

      - The old design that was deprecated since CGAL 2.3 has been removed.



* Support Library

  - New container class Compact_container, which (roughly) provides the
    flexibility of std::list, with the memory compactness of std::vector.

  - Geomview_stream: added a function gv.draw_triangles(InputIterator begin,
    InputIterator end) which draws a set of triangles much more quickly than
    one by one.

  - Number types:

      - number types are now required to provide a function: std::pair<double,
        double> to_interval(const NT &).

      - number types are now required to provide mixed operators with "int".

      - CLN support removed.

      - faster square() for MP_Float.

      - added Gmp_q.


  - Qt_widget:

      - New classes:

          - Qt_help_window: provides a simple way to show some helpful
            information about a demo as an HTML page.

          - Qt_widget_history: provides basic functionality to manipulate
            intervals of Qt_widget class. The current visible area of Qt_widget
            is mapped to an interval. Each interval could be stored in the
            Qt_widget_history object. So you can use this object to navigate in
            history. It is mostly used by Qt_widget_standard_toolbar.


      - Changes:

          - Qt_widget_standard_toolbar: is derived from QToolBar class, so pay
            attention to modify your code, if you used this class. Some public
            methods were introduced to control the history object that the
            toolbar use to navigate.

          - the icons are now part of libCGALQt.


      - Deprecated members of Qt_widget:

          - add_to_history(), clear_history(), back(), forth(): use forward(),
            back() and clear_history() of the Qt_widget_standard_toolbar
            instead.

          - custom_redraw(): use redraw_on_back() and redraw_on_front()
            instead.


      - Optimizations: the output operators of the following classes have been
        optimized:

          - CGAL::Segment_2 (now tests for intersection with the drawing area)

          - CGAL::Triangle_2 (now tests for intersection with the drawing area)

          - CGAL::Triangulation_2 (is optimized for faster display on zooming)




* Erratum in the Kernel manual

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

      - either Plane_3<Kernel>

      - or Triangle_3<Kernel>

    and Type2 any of

      - Plane_3<Kernel>

      - Line_3<Kernel>

      - Ray_3<Kernel>

      - Segment_3<Kernel>

      - Triangle_3<Kernel>


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

      - either Kernel::Plane_3

      - or Kernel::Triangle_3

    and Type2 can be any of the following:

      - Kernel::Plane_3

      - Kernel::Line_3

      - Kernel::Ray_3

      - Kernel::Segment_3

      - Kernel::Triangle_3


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



-------------------------------- Release 2.4 --------------------------------

Release date: May 2002

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

Additional supported platforms:

  - Microsoft Visual C++, version 7.

  - SunPro 5.3 (with patch 111685-05) on Solaris

  - g++ 3.1 on Linux and Solaris


The following functionality has been added or changed:



* Kernels

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


* Basic Library

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


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


  - Planar Maps and Arrangements

      - New quicker insertion functions of Planar_map_2 for cases where more
        precomputed information is available regarding the position of the
        inserted curve in the map.

      - New query function for planar maps that determines whether a given
        point is within a given face of the planar map.

      - New iterator over edges of planar maps in addition to the existing
        iterator over halfedges.

      - New copy constructor and assignment operator for arrangements.




  - Polyhedral Surface

      - new design introduced with release 2.3 now supported by VC7 compiler

      - Extended functionality of Polyhedron_incremental_builder: absolute
        indexing allows one to add new surfaces to existing ones.




  - 2D Triangulation

      - There is a new triangulation data structure replacing the two previous
        ones. This new data structure is coherent with the 3d triangulation
        data structure and offer the advantages of both previous ones. Backward
        compatibility is ensured and this change is transparent for the user of
        triangulation classes.

      - Constrained and Delaunay constrained triangulations are now able to
        handle intersecting input constraints. The behavior of constrained
        triangulations with repect to intersection of input constraints can be
        customized using an intersection tag.

      - A new class Constrained_triangulation_plus offers a constrained
        hierarchy on top of a constrained triangulations. This additionnal data
        structure describes the subdivision of the original constraints into
        edges of the triangulations.




  - 3D Triangulation

      - Running time improved by a better and more compact management of memory
        allocation

      - Various improvements and small functionalities added:

          - Triangulation_3<GT,Tds>::triangle() returns a triangle oriented
            towards the outside of the cell c for facet (c,i)

          - New function insert(Point, Locate_type, Cell_handle, int, int)
            which avoids the location step.

          - New function to get access to cells in conflict in a Delaunay
            insertion : find_conflicts() and insert_in_hole()

          - New function TDS::delete_cells(begin, end).

          - New functions : degree(v), reorient(), remove_decrease_dimension(),
            remove_from_simplex().


      - Changes of interface:

          - vertices and cells are the same for the triangulation data
            structure and the geometric triangulation

          - the triangulation data structure uses Vertex_handle (resp
            Cell_handle) instead of Vertex* (resp Cell*).

          - incident_cells() and incident_vertices() are templated by output
            iterators

          - changes in the iterators and circulators interface:

              - Iterators and circulators are convertible to handles
                automatically, no need to call "->handle()" anymore.

              - Vertex_iterator split into All_vertices_iterator and
                Finite_vertices_iterator (and similar for cells...).

              - TDS::Edge/Facet iterators now support operator->.






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


* Support Library

  - Qt_widget

      - We have added a new class for visualization of 2D CGAL objects. It is
        derived from Trolltech's Qt class QWidget and privdes a used to scale
        and pan.

      - Some demos were developed for the following packages: 2D Alpha shapes,
        2D Convex Hull, Largest empty 2D rectangle, Maximum k-gon, Minimum
        ellipse, Minimum 2D quadrilateral, 2D polygon partitioning 2D regular
        and constrained triangulation.

      - Tutorials are available to help users get used to Qt_widget




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

The following functionality is no longer supported:

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


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

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


* Known problems

  - 2D Nef Polyhedra contains a memory leak. Memory problems are also the
    likely cause of occasional run-time errors on some platforms.

  - The d-dimensional convex hull computation produces run-time errors on some
    platforms because of memory management bugs.

  - The new Halfedge Data Structure design introduced with release 2.3 does not
    work on VC6. See the release notes in the manual for more information.

  - The following deficiencies relate to planar maps, planar maps of
    intersecting curves (pmwx), arrangements and sweep line.

      - On KCC, Borland and SunPro we guarantee neither compilation nor correct
        execution for all of the packages above.

      - On VC6 and VC7 we guarantee neither compilation nor correct execution
        of the sweep line package.

      - On CC (on Irix 6.5) the trapezoidal decomposition point location
        strategy is problematic when used with planar maps, pmwx, or
        arrangements (mind that this is the default for planar maps).

      - On CC (on Irix 6.5) sweep line with polyline traits does not compile
        (mind that the so-called leda polyline traits does compile).

      - On g++ (on Irix 6.5) the segment-circle (Arr_segment_circle_traits_2)
        traits does not compile for either of the above packages.



-------------------------------- Release 2.3 --------------------------------

Release date: August 2001

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

Additional supported platform:

  - Gnu g++ 3.0 on Solaris and Linux


The following functionality has been added:



* Kernels

  - The 2D and 3D kernels now serve as models of the new kernel concept
    described in the recent paper, "An Adaptable and Extensible Geometry
    Kernel" by Susan Hert, Micheal Hoffmann, Lutz Kettner, Sylvain Pion, and
    Michael Seel to be presented at WAE 2001 (and soon available as a technical
    report). This new kernel is completely compatible with the previous design
    but is more flexible in that it allows geometric predicates as well as
    objects to be easily exchanged and adapted individually to users' needs.

  - A new kernel called Simple_homogeneous is available. It is equivalent to
    Homogeneous but without reference-counted objects.

  - A new kernel called Filtered_kernel is available that allows one to build
    kernel traits classes that use exact and efficient predicates.

  - There are two classes, Cartesian_converter and Homogeneous_converter that
    allows one to convert objects between different Cartesian and homogeneous
    kernels, respectively.

  - A new d-dimensional kernel, Kernel_d is available. It provides diverse
    kernel objects, predicates and constructions in d dimensions with two
    representations based on the kernel families Cartesean_d and Homogeneous_d


* Basic Library
Almost all packages in the basic library have been adapted to the new kernel
design to realize the flexibility this design makes possible. In several
packages, this means that the traits class requirements have changed to conform
to the function objects offered in the kernels so the kernels themselves can be
used as traits classes in many instances.


  - 2D Convex Hull
    The traits requirements have changed slightly to bring them in line with
    the CGAL kernels.

  - 3D Convex Hull

      - The function convex_hull_3 now uses a new implementation of the
        quickhull algorithm and no longer requires LEDA.

      - A new convex_hull_incremental_3 function based on the new d-dimensional
        convex hull class is available for comparison purposes.



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


  - Polygons and Polygon Operations

      - The traits class requirements have been changed.

      - The simplicity test has a completely new implementation.

      - Properties like convexity, simplicity and area can now be cached by
        polygons. You need to set a flag to select this behaviour.





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


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


  - Planar Maps and Arrangements

      - A new class Planar_map_with_intersections_2<Planar_map> for planar maps
        of possibly intersecting, possibly non-x-monotone, possibly overlapping
        curves (like Arrangement_2 but without the hierarchy tree).

      - I/O utilities for planar maps and arrangements for textual and
        graphical streams. (It is possible to save and later reload built
        planar maps or arrangements.)

      - New arrangement traits class for line segments and circular arcs
        (Arr_segment_circle_traits<NT>).

      - New faster traits for polylines specialized for using the LEDA rational
        kernel (Arr_leda_polylines_traits). The LEDA traits for segments was
        also made faster.

      - A new point location strategy (Pm_simple_point_location<Planar_map>).




  - Halfedge Data Structure

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

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


  - Polyhedral Surface

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

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

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


  - 2D Triangulation

      - The geometric traits class requirements have been changed to conform to
        the new CGAL kernels. CGAL kernel classes can be used as traits classes
        for all 2D triangulations except for regular triangulations.

      - Additionnal functionality:

          - dual method for regular triangulations (to build a power diagram)

          - unified names and signatures for various "find_conflicts()" member
            functions in Delaunay and constrained Delaunay triangulation.

          - As an alternative to the simple insert() member function, insertion
            of points in those triangulation can be performed using the
            combination of find_conflicts() and star_hole() which eventually
            allows the user to keep track of deleted faces.


      - More demos and examples



  - 3D Triangulation

      - Major improvements

          - A new class Triangulation_hierarchy_3 that allows a faster point
            location, and thus construction of the Delaunay triangulation

          - A new method for removing a vertex from a Delaunay triangulation
            that solves all degenerate cases

          - Running time of the usual location and insertion methods improved


      - A bit more functionality, such as

          - New geomview output

          - dual methods in Delaunay triangulations to draw the Voronoi diagram


      - More demos and examples

      - Changes in interface

          - Traits classes requirements have been modified

          - The kernel can be used directly as a traits class (except for
            regular triangulation)

          - insert methods in Triangulation_data_structure have a new interface




  - A new class (Alpha_shapes_3) that computes Alpha shapes of point sets in 3D
    is available.


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


  - Point_set_2

      - now independent of LEDA; based on the CGAL Delaunay triangulation

      - traits class requirements adapted to new kernel concept.

      - function template versions of the provided query operations are
        available



* Support Library

  - Number types:

      - Lazy_exact_nt<NT> is a new number type wrapper to speed up exact number
        types.

      - MP_Float is a new multiprecision floating point number type. It can do
        exact additions, subtractions and multiplications over floating point
        values.


  - In_place_list has a new third template parameter (with a suitable default)
    for an STL-compliant allocator.

  - Unique_hash_map is a new support class.

  - Union_find is a new support class.

  - Geomview_stream :

      - Geomview version 1.8.1 is now required.

      - no need to have a ~/.geomview file anymore.

      - new output operators for triangulations.

      - new output operators for Ray_2, Line_2, Ray_3, Line_3, Sphere_3.

      - various new manipulators.


  - Window stream In cooperation with Algorithmic Solutions, GmBH (distributors
    of the LEDA library), we can now offer a visualization package downloadable
    in binary form that supports visualization on a ported version of the LEDA
    window lib.


-------------------------------- Release 2.2 --------------------------------

Release date: October 2000

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

Additional supported platforms:

  - the KAI compiler (4.0) on Solaris 5.8

  - Borland C++ (5.5)


The following functionality has been added:

  - There is a new, non-reference-counted kernel, Simple_cartesian. Because
    reference counting is not used, and thus coordinates are stored within a
    class, debugging is easier using this kernel. This kernel can also be
    faster in some cases than the reference-counted Cartesian kernel.

  - New optimisation algorithms

      - Min_annulus_d - Algorithm for computing the smallest enclosing annulus
        of points in arbitrary dimension

      - Polytope_distance_d - Algorithm for computing the (squared) distance
        between two convex polytopes in arbitrary dimension

      - Width_3 - Algorithm for computing the (squared) width of points sets in
        three dimensions


  - 2D Triangulations

      - There are now two triangulation data structures available in CGAL. The
        new one uses a list to store the faces and allows one to represent two-
        dimensional triangulations embedded in three spaces as well as planar
        triangulations.

      - The triangulation hierarchy which allows fast location query is now
        available.


  - Inifinite objects can now be included in planar maps.

  - Removal as well as insertions of vertices for 3D Delaunay triangulations is
    now possible.

  - A generator for ``random'' simple polygons is now available.

  - In directory demo/Robustness, programs that demonstrate typical robustness
    problems in geometric computing are presented along with the solutions to
    these problems that CGAL provides.


The following functionality has been removed:

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



-------------------------------- Release 2.1 --------------------------------

Release date: January 2000

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

Supported platforms:

  - the newest gnu compiler (2.95.2) on Sun, SGI, Linux and Windows.

  - the Microsoft Visual C++ compiler, version 6.

  - the mips CC compiler version 7.3 under Irix.

Support for the old g++ compiler (2.8) and for mips CC 7.2 has been dropped.

The following functionality has been added:

  - Alpha shapes and weighted alpha shapes in 2D. Alpha shapes are a
    generalization of the convex hull of a point set.

  - Arrangements in 2D. Arrangements are related to and based on planar maps.
    The major difference between the two is that curves are allowed to
    intersect in the case of arrangements.

  - Extensions to triangulations in 2D. Constrained triangulations are now
    dynamic: they support insertions of new constraint as well as removal of
    existing constraints. There are also constrained Delaunay triangulations.

  - Triangulations in 3D were added, both Delaunay triangulations and regular
    triangulations.

  - Min_quadrilateral optimisations have been added. These are algorithms to
    compute the minimum enclosing rectangle/parallelogram (arbitrary
    orientation) and the minimum enclosing strip of a convex point set.

  - 2d Point_set is a package for 2d range search operations, Delaunay
    triangulation, nearest neighbor queries. This package works only if LEDA is
    installed.

  - Support for GeoWin visualization library. This also depends on LEDA.

  - Support for using the CLN number type together with CGAL.



-------------------------------- Release 2.0 --------------------------------

Release date: June 1999

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


-------------------------------- Release 1.2 --------------------------------

Release date: January 1999

Additions to release 1.1 include:


  - topological map

  - planar map overlay

  - regular and constrained triangulations


-------------------------------- Release 1.1 --------------------------------

Release date: July 1998

Additions to release 1.0 include:

  - 3D intersections

  - kD points

  - 3D convex hull

  - kD smallest enclosing sphere



-------------------------------- Release 1.0 --------------------------------

Release date: April 1998

Additions to release 0.9 include:

  - Polyhedral surfaces

  - Halfedge Data Structure

  - Planar maps



-------------------------------- Release 0.9 --------------------------------

Release date: June 1997

Initial (beta) release of the CGAL library.

