Release notes of CGAL.

----------------------------- Release 3.6.1 --------------------------------
CGAL 3.6.1 is a bug-fixes release. The following has been changed
since CGAL-3.6:

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


2. Polynomial

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


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


4. 3D Periodic Triangulations

  - Fixed bug in the triangulation hierarchy for periodic triangulations.


5. 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).


6. 3D Mesh Generation

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


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

8. IO Streams

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

CGAL 3.6 offers the following improvements and new functionality : 

1 General

  - Boost version 1.34.1 at least is now required.


2 Geometry Kernels

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


3 Arithmetic and Algebra

3.1 Algebraic Kernel (new package)

  - This new package provides implementations of 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 (available only on
    Linux and MacOS for the moment).

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


4 Polygons

4.1 2D Regularized Boolean Set-Operations

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


5 Arrangement

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



6 Triangulations and Delaunay Triangulations

6.1 2D/3D Regular Triangulations

  - Weighted_point now has a constructor from Cartesian coordinates.

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

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

  - Fixed bug in the triangulation hierarchy for periodic triangulations.

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

6.5 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).


7 Mesh Generation

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

7.2 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
    pertuber and an exuder. Each of these processes can be activated or
    not, and tuned to the users needs and to available computer resources.


8 Support library

8.1 CGAL ipelets

  - Add support for version 7 of Ipe.


----------------------------- Release 3.5.1 --------------------------------
The following has been changed since release 3.5.


1 Documentation

  - Fixes in the documentation.

  - Fixes to the bibliographic references.


2 Windows installer

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


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

The following functionality has been added or changed:

1 General

  - Additional supported platforms:
    - GNU g++ 4.4 supported.

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


2 Geometry Kernels

2.1 3D Spherical Geometry Kernel

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


3 Polygons

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

3.2 2D Straight Skeleton and Polygon Offsetting 

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


4 Arrangements

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

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


5 Triangulations and Delaunay Triangulations

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


6 Mesh Generation

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

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

7 Geometry Processing

7.1 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

7.2 Point Set Processing (new package)

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


8 Spatial Searching and Sorting

8. 1 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.

9 Support Library

9.1 CGAL_ipelets (new package)

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




------------------------- Release 3.4 ----------------------------------
The following functionality has been added or changed:

1 General

  - Additional supported platforms:
    - GNU g++ 4.3 supported.  Support for g++ 3.3 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. 
  
2 Installation

  - install_cgal has been replaced by CMake.


3 Arithmetic and Algebra

3.1 Algebraic Foundations

  - This package defines what algebra means for CGAL, in terms of concepts, classes and functions.


3.2 Polynomial  (new package)

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


3.3 Modular Arithmetic (new package)

  -  This package provides arithmetic over finite fields. 


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



4 Kernels

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

4.2 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 has been added to the kernel:

    - Related Predicates: Equal_3,
                          Has_on_3:
                           - Sphere_3, Point_3
                           - Circle_3, Point_3
                           - Sphere_3, Circle_3
                           - Plane_3, Circle_3
                           - Sphere_3, Plane_3
                           - Sphere_3, Line_3
                        Bounded_side_3
                        Has_on_bounded_side_3
                        Has_on_unbounded_side_3
                        Do_intersect_3:
                               - Sphere_3, Sphere_3
                               - Sphere_3, Plane_3

    - Constructions: Construct_circle_3
                         Construct_supporting_plane_3
                         Construct_supporting_sphere_3
                         Construct_diametral_sphere_3
                         Intersect_3:
                              - Sphere_3, Sphere_3
                              - Sphere_3, Plane_3
                         Construct_bbox_3
                         Compute_area_divided_by_pi_3
                         Compute_squared_length_divided_by_pi_square_3
                         Compute_approximate_squared_length_3
                         Compute_approximate_area_3
                         Construct_radical_plane_3

  - Member functions manipulating Circle_3 have been added to Plane_3 and Sphere_3 as well.
  - Global functions: Intersections, Do_intersects and radical_plane.
  - The missing intersection/do_intersect between Line_3 and Line_3 has been added as well.



5 Data Structures and Algorithms

5.1 3D Minkowski Sum (new package)

  - This package provides a function, which computes the Minkowski sum of two point sets in R^3

5.2 Convex Decomposition of Polyhedra (new package)

  - This package allows to decompose a 3D Nef Polyhedron in convex parts.


5.3 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


5.4 3D Nef Polyhedron

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


5.5 CGAL and the Qt4 GraphicsView (new package)

  - 2D CGAL Kernel objects and many data structures have can be rendered in a QGraphicsView
    using the Qt4 based GraphicsView framework.  We encourage users to switch from
    Qt3 to Qt4, removed the manual of the Qt3 related manual pages, as Qt3 support
    will be dropped starting from the next release.


5.6 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
    mechanism 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.


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


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


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

5.10 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 ----------------------------------
The following corrections have been made:

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.


Kernel
- Fixed forgotten derivation in Circular_kernel_2::Has_on_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.


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 ----------------------------------
The following functionality has been added or changed:

1  General

Additional supported platforms:
 - GNU g++ 4.1 and 4.2 supported
 - Intel C++ compiler 9
 - Microsoft Visual C++ compiler 8.0

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.


2 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


3 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  and number types.


4 Number Types

- Fixed_precision_nt and Filtered_exact number types have been removed.


5 Kernels

5.1 Circular Kernel in 2D

  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. 


5.2 Linear Kernel

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



6 Data Structures and Algorithms

6.1 Surface Mesh Simplification (new package)

  This package provides a mesh simplification framework using edge collapse
  operations, and provides the Turk/Lindstrom simplification algorithm.


6.2 Estimation of Local Differential Properties (new package)

  This package allows to compute local differential quantities of a surface 
  from a point sample


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


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


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


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


6.7 Surface Mesh Parametrization

- Added Jacobi and SSOR preconditioners to OpenNL solver, which makes it
  much faster and more stable.
- Updated the precompiled libraries for BLAS, LAPACK and TAUCS.


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


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

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


6.11 Optimal Distances

- Polytope_distance_d
  * support for homogeneous points
  * bugfix in fast exact version

6.12 Bounding Volumes

- Min_annulus_d:   
  * support for homogeneous points
  * bugfix in fast exact version


7 Support Library


7.1 CGAL and the Boost Graph Library (BGL)

  This package provides the glue layer for several CGAL data structures such 
  that they become models of the BGL graph concept.
 

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


7.3 Linear and Quadratic Programming Solver

  This package contains algorithms for minimizing linear and convex quadratic 
  functions over polyhedral domains, described by linear equations and 
  inequalities. 


----------------------------- Release 3.2.1---------------------------------
This is a bug fix release

- Number Types
  Fixed 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 ----------------------------------
The following functionality has been added or changed:

1  General

The following platforms are no longer supported:
 - SunPro CC compiler versions 5.4 and 5.5 on Solaris
 - SGI Mips Pro C++ compiler

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

2 Installation

 - The installation script tries to find third party libraries
   at "standard" locations.

 - OS-specific packages for Windows, MacOSX and Linux (RPM and Debian).


3 Manuals 
 
 - User and Reference manual pages of a package are in the same chapter 
 - General restructuring of the high-level presentation of the library


4 Kernels

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


5 Data Structures and Algorithms

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

5.2  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
polygon with holes and an algorithm to construct inward offset
polygons at any offset distance given a straight skeleton.


5.3  2D Voronoi Diagram (new package)

The 2D Voronoi diagram package provides an adaptor that adapts a
2-dimensional triangulated Delaunay graph to the corresponding a
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.


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


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


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


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


5.8 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
behavior. 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.


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


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


5.11  Geometric Optimization (major revision)

The underlying QP solver which is the foundation for several algorithms
in the Geometric Optimization chapter has been completely rewritten.


5.12 Smallest Enclosing Ellipsoid  (new package)

This algorithm is new in the chapter Geometric Optimisation


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




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

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:

1  All

 - The CORE 1.7 library for exact real arithmetic (http://www.cs.nyu.edu/exact/core).
 - Updated GMP to 4.1.3 (http://www.swox.com/GMP)
 - Added MPFR, a library for multiple-precision floating-point computations with exact 
   rounding (http://www.mpfr.org)
 - Added Boost 1.32.0 (http://www.boost.org).


2  Installation

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


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


4  Kernels

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


5  Basic Library


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



5.2  2D Conforming Triangulations and Meshes (new package)

An implementation of Shewchuk's algorithm to construct conforming
triangulations and 2D meshes.



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


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


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


5.6  dD 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.


5.7  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 Rounding is 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.


5.8  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 vertex removal, the ability to keep or drop hidden vertices, 
                filtered traits class, and nearest_power_vertex(). 



5.9  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 functions 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.


5.10  Triangulation_2

 - added a filtered trait class for Regular triangulation.
 - added split and join operations in the triangulation data structure class.


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


5.11  Min_ellipse_2

  - made access to approximate double representation public
  - fixed bugs in conversion to double representation
  - added is_circle() method
  - minor performance improvements


5.12  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



5.13  Polyhedron_3

 - New Tutorial on CGAL Polyhedron for Subdivision Algorithms  with
   interactive demo viewer in source code available.
   (http://www.cgal.org/Tutorials/Polyhedron)
          
 - Added example program for efficient self-intersection test.
 - Added small helper functions, such as vertex_degree, facet_degree,
   edge_flip, and is_closed.




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

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

Triangulation_2 :
- 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 intersect()
  documentation.
----------------------------- Release 3.0 ------------------------------------
Version 3.0 differs from version 2.4 in the platforms that are supported, in
functionality, and in licensing. 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 Geometry
Factory (www.geometryfactory.com).


Additional supported platforms:

    * MS Visual C++, version 7.1.
    * SunPro CC versions 5.4 and 5.5 on Solaris
    * GNU g++ version 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.

Platforms not supported anymore:

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

    * The CORE library (http://www.cs.nyu.edu/exact/core/) for exact
      computations is now distributed as part of CGAL as well.

All:
----

    * All demos have been switched from LEDA window to QT.

Kernel:
-------

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

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

    * Min_sphere_of_spheres_d (new package): Algorithms to compute the smallest
      enclosing sphere of a given set of spheres in R^d.  The package provides
      an algorithm with maximal expected running time $O(2^{O(d)} n)$ and a
      fast and robust heuristic (for dimension less than 30).

    * Spatial Searching (new package): Provides exact and approximate distance
      browsing in a set of points in $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 (new package in Geometric Optimisation):
       Given a set of points P in the plane, the class
       Largest_empty_iso_rectangle_2<T> 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.

    * Triangulations 2D and 3D:
      - 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 mechanism 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
        customization of base classes in most cases.

    * Triangulations 2D:
      - 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).

    * Triangulations 3D:
      - 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 structure 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:
      - 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:
           * Conic traits - Arr_conic_traits_2
             Support finite segments of ellipses, hyperbolas and parabolas, as
	     well as line segments. The traits require an exact real number-
	     type, such as leda_real or CORE::Expr.

           * Segment cached traits - Arr_segment_cached_traits_2
	     This class uses an improved representation for segments that helps
	     avoiding cascaded computations, thus achieving faster running
	     times. To work properly, an exact rational number-type should be
	     used.

           * Polyline traits - Arr_polyline_traits_2
             The polyline traits class has been reimplemented to work in a more
	     efficient, generic manner. The new class replaces the obsolete
	     Arr_polyline_traits class. It is parameterized with a segment
	     traits class.

           * Hyperbola and segment traits - Arr_hyper_segment_traits_2
             Supports line segments and segments of canonical hyperbolas.
	     This is the type of curves that arise when projecting segments
	     in three-space rotationally around a line onto a plane containing
	     the line. Such projections are often useful in CAD/CAM problems.

        4. Removed old traits class:
           a) 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

           b) 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.

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

        1. Halfedge_handle
           non_intersecting_insert(const X_monotone_curve_2 & cv,
                                   Change_notification * en = NULL)
        2. Halfedge_iterator
           non_intersecting_insert(const X_monotone_curve_2_iterator & begin,
                                   const X_monotone_curve_2_iterator & end,
                                   Change_notification * en = NULL)
        3. Halfedge_handle
           non_intersecting_insert_in_face_interior(
                                   const X_monotone_curve_2 & cv,
                                   Face_handle f,
                                   Change_notification * en = NULL)
        4.  Halfedge_handle
            non_intersecting_insert_from_vertex(
                                   const X_monotone_curve_2 & cv,
                                   Halfedge_handle h,
                                   Change_notification * en = NULL)
        5.  Halfedge_handle
            non_intersecting_insert_at_vertices(
                                   const X_monotone_curve_2 & cv,
                                   Halfedge_handle h1,
                                   Halfedge_handle h2,
                                   Change_notification * en = NULL)
        6.  Halfedge_handle
            non_intersecting_insert_from_vertex(
                                   const X_monotone_curve_2 & cv,
                                   Vertex_handle v1,
                                   Change_notification * en = NULL)
        7.  Halfedge_handle
            non_intersecting_insert_at_vertices(
                                   const X_monotone_curve_2 & cv,
                                   Vertex_handle v1,
                                   Vertex_handle v2,
                                   Change_notification * en = NULL)

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

    * 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.
      - Optimisations:
        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)



----------------------------- Release 2.4 ------------------------------------
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) 
   g++ 3.1 

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

  2D 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 respect 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 additional 
      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

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.  This code is
       distributed under a dual QPL and commercial license.
     - 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, 
   2D intersections

Also, attempts have been made to assure compatibility with upcoming LEDA
releases that introduce 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 any of the above packages.

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

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

Additional supported platforms:

   Gnu g++ 3.0 on Solaris, 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, Michael 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 Cartesian_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.

   3D Convex Hull 
     - The convex_hull_3 function now uses a new implementation of the 
       quickhull algorithm that 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

  Polygon

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

  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.

  Planar Polygon Partitioning
     New package offering functions to partition planar polygons into
     convex and y-monotone pieces.

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

     Additional 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 

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

  Geometric Optimisation

     The traits requirements for Matrix_search and Min_quadrilateral_2
     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 and
      converted to kernel traits
    - function template versions of the provided query operations


Support Library:
----------------
  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. 

  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.

  Number types :
    - Lazy_exact_nt<NT> is a new number type wrapper to speed up exact 
      number types.
    - MP_Float is a new multi-precision floating point number type. It can 
      do exact additions, subtractions and multiplications over 
      floating point values.

  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 support visualization on a ported
    version of the LEDA window lib.


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

Version 2.2 differs from version 2.2 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.

  -  Infinite 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 since the code could not be adapted to all supported 
       platforms.  Arrangements can often be used as a substitute.

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

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

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

Additions to release 1.1 include: 
     - topological map 
     - planar map overlay 
     - regular and constrained triangulations 

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

Additions to release 1.0 include:

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


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

Additions to release 0.9 include:

     - Polyhedral surfaces 
     - Halfedge Data Structure
     - Planar maps 

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

Initial (beta) release of the CGAL library.

------------------------------------------------------------------------------
