songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cgal/Installation/CHANGES

3517 lines
118 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

-------------------------------- Release 4.3 --------------------------------
Release date: September 2013
* 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.
* 2D Arrangements
- The point location functionalities now uses a boost::variant instead of a
CGAL::Object. For convenience, The previous behavior can be restored by
defining the macro CGAL_ARR_POINT_LOCATION_VERSION to 1.
* 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 intersection functions and functors used to returned 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.
- 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.
* 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 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.
* 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
* Combinatorial Maps
- Two bug fixes: do not use the 2 least significant bits for cell attribute
without dart support; add share a mark in 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.
* 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 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.
* 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.
* 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.
* 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.
Mesh_cell_base_3 is now deprecated.
- 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.
* 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 &amp;).
- 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.
Reference in New Issue View Git Blame Copy Permalink