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

1117 lines
47 KiB
Plaintext
Raw Blame History

----------------------------- Release 3.1 ----------------------------------
Version 3.1 differs from version 3.0 in the platforms that are supported and
in functionality. There have also been a number of bug fixes for this release.
Additional supported platforms:
- MS Visual C++, version 7.3. and 8.0
- Intel 8.0
- SunPro CC versions 5.4 and 5.5 on Solaris
- GNU g++ versions 3.4 on Linux, Solaris, Irix, cygwin, FreeBSD, and MacOS X
- Darwin (MacOS X) and IA64/Linux support.
The following platforms are no longer supported:
- MS Visual C++, version 7.0
The following functionality has been added or changed:
1 All
- The CORE 1.7 library for exact real arithmetic (http://www.cs.nyu.edu/exact/core).
- Updated GMP to 4.1.3 (http://www.swox.com/GMP)
- Added MPFR, a library for multiple-precision floating-point computations with exact
rounding (http://www.mpfr.org)
- Added Boost 1.32.0 (http://www.boost.org).
2 Installation
- new option --disable-shared to omit building libCGAL.so.
3 Manuals
- Merged all major manuals in one multi-part manual, which provides
now cross-links between the CGAL Kernel, the CGAL Basic Library,
and the CGAL Support Library HTML manuals.
- Improved layout.
4 Kernels
- Improved efficiency of filtered kernels.
- More predicates and constructions.
5 Basic Library
5.1 2D Segment Voronoi Diagram (new package)
A data structure for Voronoi diagrams of segments in the plane under
the Euclidean metric. The Voronoi edges are arcs of straight lines and
parabolas. The algorithm provided in this package is incremental.
5.2 2D Conforming Triangulations and Meshes (new package)
An implementation of Shewchuk's algorithm to construct conforming
triangulations and 2D meshes.
5.3 3D Boolean Operations on Nef Polyhedra(new package)
A new class (Nef_polyhedron_3) representing 3D Nef polyhedra, a
boundary representation for cell-complexes bounded by halfspaces that
supports boolean operations and topological operations in full
generality including unbounded cells, mixed dimensional cells (e.g.,
isolated vertices and antennas). Nef polyhedra distinguish between
open and closed sets and can represent non-manifold geometry.
5.4 2D and Surface Function Interpolation (new package)
This package implements different methods for scattered data
interpolation: Given measures of a function on a set of discrete data
points, the task is to interpolate this function on an arbitrary query
point. The package further offers functions for natural neighbor
interpolation.
5.5 Planar Nef polyhedra embedded on the sphere (new package)
A new class (Nef_polyhedron_S2) designed and supported mainly to
represent sphere neighborhoods around vertices of the three-
dimensional Nef polyhedra.
5.6 dD Box_intersection_d (new package)
A new efficient algorithm for finding all intersecting pairs for large
numbers of iso-oriented boxes, i.e., typically these will be bounding
boxes of more complicated geometries. Useful for (self-) intersection
tests of surfaces etc.
5.7 2D Snap Rounding (new package)
Snap Rounding is a well known method for converting
arbitrary-precision arrangements of segments into a fixed-precision
representation. In the study of robust geometric computing, it can be
classified as a finite precision approximation technique. Iterated
Snap Rounding is a modification of Snap Rounding in which each vertex
is at least half-the-width-of-a-pixel away from any non-incident
edge. This package supports both methods.
5.8 3D Triangulations
- Triangulation_3: added operator==(), removed push_back() and copy_triangulation().
- Delaunay_3 : added nearest_vertex(), move_point(), vertices_in_conflict().
- Regular_3 : added vertex removal, the ability to keep or drop hidden vertices,
filtered traits class, and nearest_power_vertex().
5.9 Planar_map and Arrangement_2
- The interface of the two traits functions that compute the
intersection of two given curves changed. The functions
nearest_intersection_to_right() and nearest_intersection_to_left()
return an object of type CGAL::Object that represents either an
empty intersection, a point, or an overlapping subcurve.
- Requirements to define two binary tags were added to the traits
concept of the Planar_map as follows:
- Has_left_category - indicates whether the functions
curves_compare_y_at_x_left() and nearest_intersection_to_left()
are implemented in the traits model.
Has_reflect_category - indicates whether the functions
point_reflect_in_x_and_y() and curve_reflect_in_x_and_y() are
implemented in the traits model. They can be used as an
alternative to the two functions in the previous item.
- A new constructor of the Segment_cached_2 type that represents a
segment in the Arr_segment_cached_traits_2 traits class was
introduced. The new constructor accepts the segment endpoints as
well as the coefficients of the underlying line.
- A new version of the conic-arc traits, based on CORE version 1.7
was introduced. This new traits class makes use of CORE's rootOf()
operator to compute the intersection points in the arrangement,
making its code much simpler and more elegant than the previous
version. In addition, new constructors for conic arcs are
provided. The new traits class usually performs about 30% faster
than the version included in CGAL 3.0
- The traits class that handles continuous piecewise linear curves,
namely Arr_polyline_traits_2, was rewritten. The new class is
parametrized with a traits class that handles segments, say
Segment_traits. The polyline curve defined within the
Arr_polyline_traits_2 class is implemented as a vector of segments
of type Segment_traits::Curve_2.
- A meta traits class, namely Arr_curve_data_traits_2, that extends
the curve type of the planar-map with arbitrary additional data was
introduced. It should be instantiated with a regular traits-class
and a class that contains all extraneous data associated with a
curve.
- The class that represents the trapezoidal-decomposition point
location strategy was renamed to Pm_trapezoid_ric_point_location.
- The Arrangement demo was rewritten. It covers many more features,
has a much better graphical user interface, and comes with online
documentation.
- Few bugs in the sweep-line module related to overlapping vertical
segments were fixed. This module is used by the aggregate insert
method that inserts a collection of curves at once.
5.10 Triangulation_2
- added a filtered trait class for Regular triangulation.
- added split and join operations in the triangulation data structure class.
5.11 Alpha_shapes_3
- major changes in the implementation of the class Alpha_shapes_3.
- New implementation results in a true GENERAL mode allowing null and
negative alpha-values. It also fixed the edges classification bug
and introduces a classification of vertices.
5.11 Min_ellipse_2
- made access to approximate double representation public
- fixed bugs in conversion to double representation
- added is_circle() method
- minor performance improvements
5.12 Min_sphere_of_spheres_d:
- The models
Min_sphere_of_spheres_d_traits_2<K,FT,UseSqrt,Algorithm>,
Min_sphere_of_spheres_d_traits_3<K,FT,UseSqrt,Algorithm>, and
Min_sphere_of_spheres_d_traits_d<K,FT,Dim,UseSqrt,Algorithm>
of concept MinSphereOfSpheresTraits now represent a sphere
as a std::pair<Point,Radius> (and not any more as a
CGAL::Weighted_point<Point,Weight>)
- Internal code cleanup; in particular, implementation details
don't pollute the namespace CGAL anymore
5.13 Polyhedron_3
- New Tutorial on CGAL Polyhedron for Subdivision Algorithms with
interactive demo viewer in source code available.
(http://www.cgal.org/Tutorials/Polyhedron)
- Added example program for efficient self-intersection test.
- Added small helper functions, such as vertex_degree, facet_degree,
edge_flip, and is_closed.
----------------------------- Release 3.0.1 ----------------------------------
This is a bug-fix release.
No new features have been added in 3.0.1. Here is the list of bug-fixes.
Polyhedron:
- Fixed wrong include files for output support. Added example.
Planar_map :
- Fixed the so called "Walk-along-a-line" point-location strategy to correctly
handle a degenerate case.
Triangulation_2 :
- added missing figure in html doc
- in Line_face_circulator_2.h :
Fixed changes made to support handles with a typedef to iterator.
The fix concerns operator== and !=.
Alpha_shapes_3 :
- fixed classify member function for edges
Number types :
- Lazy_exact_nt :
- added the possibility to select the relative precision of to_double()
(by default 1e-5). This should fix reports that some circumcenters
computations have poor coordinates, e.g. nan).
- when exact computation is triggered, the interval is recomputed, this
should speed up some kinds of computations.
- to_interval(Quotient<MP_Float>) : avoid spurious overflows.
Kernel :
- missing acknowledgment in the manual and minor clarification of intersect()
documentation.
----------------------------- Release 3.0 ------------------------------------
Version 3.0 differs from version 2.4 in the platforms that are supported, in
functionality, and in licensing. There have also been a number of bug fixes for
this release.
The license has been changed to either the LGPL (GNU Lesser General Public
License v2.1) or the QPL (Q Public License v1.0) depending on each package.
So CGAL remains free of use for you, if your usage meets the criteria of these
licenses, otherwise, a commercial license has to be purchased from Geometry
Factory (www.geometryfactory.com).
Additional supported platforms:
* MS Visual C++, version 7.1.
* SunPro CC versions 5.4 and 5.5 on Solaris
* GNU g++ version 3.2 and 3.3 on Linux, Solaris, Irix, cygwin, and FreeBSD.
* MipsPRO CC 7.30 and 7.40 with both the n32 and n64 ABIs.
Platforms not supported anymore:
* MS Visual C++, version 6.
* GNU g++ 2.95.2 (2.95.3 is still supported)
* Kai C++ and Borland C++, all versions
The following functionality has been added or changed:
* The CORE library (http://www.cs.nyu.edu/exact/core/) for exact
computations is now distributed as part of CGAL as well.
All:
----
* All demos have been switched from LEDA window to QT.
Kernel:
-------
* 3 typedefs have been added to ease the choice of a robust and fast kernel:
- Exact_predicates_inexact_constructions_kernel
- Exact_predicates_exact_constructions_kernel
- Exact_predicates_exact_constructions_kernel_with_sqrt
* Progress has been made towards the complete adaptability and
extensibility of our kernels.
* New faster Triangle_3 intersection test routines.
* Added a Kernel concept archetype to check that generic algorithms
don't use more functionality than they should.
* A few more miscellaneous functions.
Basic Library:
--------------
* Apollonius graph (new package): Algorithms for computing the Apollonius
graph in two dimensions. The Apollonius graph is the dual of the
Apollonius diagram, also known as the additively weighted Voronoi
diagram. The latter can be thought of as the Voronoi diagram of a set
of circles under the Euclidean metric, and it is a generalization of the
standard Voronoi diagram for points. The algorithms provided are
dynamic.
* Min_sphere_of_spheres_d (new package): Algorithms to compute the smallest
enclosing sphere of a given set of spheres in R^d. The package provides
an algorithm with maximal expected running time $O(2^{O(d)} n)$ and a
fast and robust heuristic (for dimension less than 30).
* Spatial Searching (new package): Provides exact and approximate distance
browsing in a set of points in $d$-dimensional space using
implementations of algorithms supporting:
- both nearest and furthest neighbor searching
- both exact and approximate searching
- (approximate) range searching
- (approximate) $k$-nearest and $k$-furthest neighbor searching
- (approximate) incremental nearest and incremental furthest neighbor
searching
- query items representing points and spatial objects.
* Kd-tree : this package is deprecated, its documentation is removed.
It is replaced by the Spatial Searching package.
* Largest_empty_rectangle_2 (new package in Geometric Optimisation):
Given a set of points P in the plane, the class
Largest_empty_iso_rectangle_2<T> is a data structure that
maintains an iso-rectangle with the largest area among all
iso-rectangles that are inside a given iso-rectangle bounding box,
and that do not contain any point of the point set P.
* Triangulations 2D and 3D:
- The classes Triangulation_data_structure_2 (and 3), which implements
the data structure for 2D triangulation class, now makes use of
CGAL::Compact_container (see Support Library section below).
- The triangulation classes use a Rebind mechanism to provide
the full flexibility on Vertex and Face base classes.
This means that it is possible for the user to derive its own Face
of Vertex base class, adding a functionality that makes use of
types defined by the triangulation data structure like Face_handle
or Vertex_handle.
- New classes Triangulation_vertex_base_with_info_2 (and 3) and
Triangulation_face_base_with_info_2 (and 3) to make easier the
customization of base classes in most cases.
* Triangulations 2D:
- Regular triangulation provides an easy access to hidden points.
- The Triangulation_hierarchy_2, which provide an efficient location
data structure, can now be used with any 2D triangulation class plugged
in (including Regular triangulations).
* Triangulations 3D:
- faster vertex removal function in Delaunay_triangulation_3.
- Delaunay_triangulation_3 is now independent of the order of insertions
of the points (in case of degenerate cosphericity).
- Regular_triangulation_3 now hides vertices (and updates itself) when
inserting a coinciding point with greater weight. This required a new
predicate.
- deprecated functions: copy_triangulation(), push_back(),
set_number_of_vertices().
- Triangulation_3 now gives non-const access to the data structure.
* Interval_skip_list (new package)
An interval skip list is a data structure for finding all intervals
that contain a point, and for stabbing queries, that is for answering
the question whether a given point is contained in an interval or not.
* Planar Maps and Arrangements:
- Traits classes.
1. New traits hierarchy and interface:
The set of requirements was made sound and complete. A couple of
requirements were eliminated, few others were redefined, and some
were renamed. A hierarchy of three traits classes for the
Planar_map_2, Planar_map_with_intersections_2, and Arrangement_2
types was established to include only the necessary requirements at
each level. It was determined that for the aggregate insertion-
operation based on a sweep-line algorithm only a subset of the
requirements is needed. Preconditions were added where appropriate
to tighten the requirements further.
The following functions have been renamed:
* point_is_same() renamed to point_equal()
* curve_is_same() renamed to curve_equal()
* curve_is_in_x_range() renamed to point_in_x_range()
* curve_compare_at_x() renamed to curves_compare_y_at_x()
Furthermore, a precondition has been added that the reference
point is in the x-range of both curves.
* curve_compare_at_x_right() renamed to
curves_compare_y_at_x_to_right().
Furthermore, a precondition has been added that both curves are
equal at the reference point and defined to its right.
* curve_compare_at_x_left() renamed to
curves_compare_y_at_x_to_left().
Furthermore, a precondition has been added that both curves are
equal at the reference point and defined to its right.
* curve_get_point_status() renamed to curve_compare_y_at_x().
Furthermore, a precondition has been added that the point is in
the x-range of the curve. Consequently, the function now returns a
Comparison_result (instead of a special enum).
* make_x_monotone() renamed to curve_make_x_monotone()
See more details below.
* curve_flip() renamed to curve_opposite()
The following functions have been removed:
- curve_is_between_cw()
- point_to_left()
- point_to_right()
- is_x_monotone()
- point_reflect_in_x_and_y()
- curve_reflect_in_x_and_y()
- do_intersect_to_right()
- do_intersect_to_left()
Most functions, are required by the PlanarMapTraits_2 concept,
except for the make_x_monotone(), nearest_intersection_to_right(),
nearest_intersection_to_left(), curves_overlap() and
curve_opposite(). PlanarMapWithIntersectionsTraits_2 requires all
these functions, except curve_opposite(), needed only by the
ArrangementTraits_2 concept.
Furthermore, the two functions curve_compare_at_x_left() and
nearest_intersection_to_left() can be omitted, if the two functions
point_reflect_in_x() and curve_reflect_in_x() are implemented.
Reflection can be avoided, if the two _left functions are supplied.
2. The type X_curve_2 of the PlanarMapWithIntersectionsTraits_2
concept was renamed to X_monotone_curve_2, and the distinction
between this type and the Curve_2 type was made firm. The method
is_x_monotone() of the PlanarMapWithIntersectionsTraits_2 concept
was removed. The related method curve_make_x_monotone() is now
called for each input curve of type Curve_2 when curves are inserted
into a Planar_map_with_intersections_2 to subdivide the input curve
into x-monotone sub-curves (and in case the curve is already
x-monotone, this function is responsible for casting it to an
x-monotone curve).
3. New and improved traits classes:
* Conic traits - Arr_conic_traits_2
Support finite segments of ellipses, hyperbolas and parabolas, as
well as line segments. The traits require an exact real number-
type, such as leda_real or CORE::Expr.
* Segment cached traits - Arr_segment_cached_traits_2
This class uses an improved representation for segments that helps
avoiding cascaded computations, thus achieving faster running
times. To work properly, an exact rational number-type should be
used.
* Polyline traits - Arr_polyline_traits_2
The polyline traits class has been reimplemented to work in a more
efficient, generic manner. The new class replaces the obsolete
Arr_polyline_traits class. It is parameterized with a segment
traits class.
* Hyperbola and segment traits - Arr_hyper_segment_traits_2
Supports line segments and segments of canonical hyperbolas.
This is the type of curves that arise when projecting segments
in three-space rotationally around a line onto a plane containing
the line. Such projections are often useful in CAD/CAM problems.
4. Removed old traits class:
a) The models of the PlanarMapWithIntersectionsTraits_2 concept
below became obsolete, as the new conic traits, namely
Arr_conic_traits_2, supports the same functionality and is much
more efficient.
- Arr_circles_real_traits
- Arr_segment_circle_traits
b) The segment traits class and the new polyline traits class were
reimplemented using standard CGAL-kernel calls. This essentially
eliminated the corresponding leda traits classes, namely:
- Pm_leda_segment_traits_2
- Arr_leda_segment_traits_2
- Arr_leda_polyline_traits
With the use of the Leda_rat_kernel new external package the same
functionality can be achieved with less overhead and more
efficiency.
- The Sweep_line_2 package was reimplemented. As a consequence it is much
more efficient, its traits is tighter (namely neither the two _left nor
the reflection functions are required), and its interface has changed a
bit.
1. The following global functions have been removed:
- sweep_to_produce_subcurves_2()
- sweep_to_produce_points_2()
- sweep_to_construct_planar_map_2()
Instead, the public methods of the Sweep_line_2 class listed below
were introduced:
* get_subcurves() - Given a container of curves, this function
returns a list of curves that are created by intersecting the
input curves.
* get_intersection_points() - Given a range of curves, this function
returns a list of points that are the intersection points of the
curves.
* get_intersecting_curves() - Given a range of curves, this function
returns an iterator to the beginning of a range that contains the
list of curves for each intersection point between any two curves
in the specified range.
2. It is possible to construct a planar map with intersections (or an
arrangement) by inserting a range of curves into an empty map. This
will invoke the sweep-line process to construct the map more
efficiently.
- New interface functions to the Planar_map_with_intersections_2 class.
The Planar_map_with_intersections_2 class maintains a planar map of
input curves that possibly intersect each other and are not necessarily
x-monotone. If an input curve, or a set of input curves, are known to
be x-monotone and pairwise disjoint, the new functions below can be
used to insert them into the map efficiently.
1. Halfedge_handle
non_intersecting_insert(const X_monotone_curve_2 & cv,
Change_notification * en = NULL)
2. Halfedge_iterator
non_intersecting_insert(const X_monotone_curve_2_iterator & begin,
const X_monotone_curve_2_iterator & end,
Change_notification * en = NULL)
3. Halfedge_handle
non_intersecting_insert_in_face_interior(
const X_monotone_curve_2 & cv,
Face_handle f,
Change_notification * en = NULL)
4. Halfedge_handle
non_intersecting_insert_from_vertex(
const X_monotone_curve_2 & cv,
Halfedge_handle h,
Change_notification * en = NULL)
5. Halfedge_handle
non_intersecting_insert_at_vertices(
const X_monotone_curve_2 & cv,
Halfedge_handle h1,
Halfedge_handle h2,
Change_notification * en = NULL)
6. Halfedge_handle
non_intersecting_insert_from_vertex(
const X_monotone_curve_2 & cv,
Vertex_handle v1,
Change_notification * en = NULL)
7. Halfedge_handle
non_intersecting_insert_at_vertices(
const X_monotone_curve_2 & cv,
Vertex_handle v1,
Vertex_handle v2,
Change_notification * en = NULL)
* Polyhedral Surface:
- The old design that was deprecated since CGAL 2.3 has been removed.
- Class Polyhedron_incremental_builder_3:
- Renamed local enum ABSOLUTE to ABSOLUTE_INDEXING, and RELATIVE to
RELATIVE_INDEXING to avoid conflicts with similarly named
macros of another library.
- Changed member functions add_vertex(), begin_facet(), and end_facet()
to return useful handles.
- Added test_facet() to check facets for validity before adding them.
- Added vertex( size_t i) to return Vertex_handle for index i.
* Halfedge Data Structure:
- The old design that was deprecated since CGAL 2.3 has been removed.
Support Library:
----------------
* New container class Compact_container, which (roughly) provides the
flexibility of std::list, with the memory compactness of std::vector.
* Geomview_stream: added a function
gv.draw_triangles(InputIterator begin, InputIterator end)
which draws a set of triangles much more quickly than one by one.
* Number types:
- number types are now required to provide a function:
std::pair<double, double> to_interval(const NT &).
- number types are now required to provide mixed operators with "int".
- CLN support removed.
- faster square() for MP_Float.
* Qt_widget:
- New classes:
- Qt_help_window: provides a simple way to show some helpful
information about a demo as an HTML page.
- Qt_widget_history: provides basic functionality to manipulate
intervals of Qt_widget class. The current visible area of Qt_widget
is mapped to an interval. Each interval could be stored in the
Qt_widget_history object. So you can use this object to navigate in
history. It is mostly used by Qt_widget_standard_toolbar.
- Changes:
- Qt_widget_standard_toolbar: is derived from QToolBar class, so pay
attention to modify your code, if you used this class. Some public
methods were introduced to control the history object that the
toolbar use to navigate.
- the icons are now part of libCGALQt.
- Deprecated members of Qt_widget:
- add_to_history(), clear_history(), back(), forth(): use forward(),
back() and clear_history() of the Qt_widget_standard_toolbar instead.
- custom_redraw(): use redraw_on_back() and redraw_on_front() instead.
- Optimisations:
the output operators of the following classes have been optimized:
- CGAL::Segment_2 (now tests for intersection with the drawing area)
- CGAL::Triangle_2 (now tests for intersection with the drawing area)
- CGAL::Triangulation_2 (is optimized for faster display on zooming)
----------------------------- Release 2.4 ------------------------------------
Version 2.4 differs from version 2.3 in the platforms that are supported and
in functionality. There have also been a number of bug fixes for this release.
Additional supported platforms:
Microsoft Visual C++, version 7.
SunPro 5.3 (with patch 111685-05)
g++ 3.1
The following functionality has been added or changed:
Kernels:
Point_d has been removed from the 2D and 3D kernels. This type is
now available from the d-dimensional kernel only.
Basic Library:
2D Polygon Partition
- Traits requirements for optimal partitioning have been changed slightly.
2D Sweep line
- A new package that implements a sweep-line algorithm to compute
arrangements of curves for different families of curves, which are
not necessarily line segments (e.g., it also works for circular arcs).
The resulting output can be the list of vertex points, the resulting
subcurves or a planar map.
2D Planar Maps and Arrangements
- New quicker insertion functions of Planar_map_2 for cases where more
precomputed information is available regarding the position of
the inserted curve in the map.
- New query function for planar maps that determines whether a given
point is within a given face of the planar map.
- New iterator over edges of planar maps in addition to the existing
iterator over halfedges.
- New copy constructor and assignment operator for arrangements.
Polyhedral Surface
- new design introduced with release 2.3 now supported by VC7 compiler
- Extended functionality of Polyhedron_incremental_builder:
absolute indexing allows one to add new surfaces to existing ones.
2D Triangulation
- There is a new triangulation data structure replacing the two
previous ones. This new data structure is coherent with the 3d
triangulation data structure and offer the advantages of both
previous ones. Backward compatibility is ensured and this change
is transparent for the user of triangulation classes.
- Constrained and Delaunay constrained triangulations are now able
to handle intersecting input constraints.
The behavior of constrained triangulations with respect to
intersection of input constraints can be customized using
an intersection tag.
- A new class Constrained_triangulation_plus offers a constrained
hierarchy on top of a constrained triangulations. This additional
data structure describes the subdivision of the original constraints
into edges of the triangulations.
3D Triangulation
- Running time improved by a better and more compact management of
memory allocation
- Various improvements and small functionalities added:
- Triangulation_3<GT,Tds>::triangle() returns a triangle oriented
towards the outside of the cell c for facet (c,i)
- New function insert(Point, Locate_type, Cell_handle, int, int)
which avoids the location step.
- New function to get access to cells in conflict in a Delaunay
insertion : find_conflicts() and insert_in_hole()
- New function TDS::delete_cells(begin, end).
- New functions : degree(v), reorient(), remove_decrease_dimension(),
remove_from_simplex().
- Changes of interface:
- vertices and cells are the same for the triangulation data
structure and the geometric triangulation
- the triangulation data structure uses Vertex_handle (resp
Cell_handle) instead of Vertex* (resp Cell*).
- incident_cells() and incident_vertices() are templated by output
iterators
- changes in the iterators and circulators interface:
- Iterators and circulators are convertible to handles
automatically, no need to call "->handle()" anymore.
- Vertex_iterator split into All_vertices_iterator and
Finite_vertices_iterator (and similar for cells...).
- TDS::Edge/Facet iterators now support operator->.
2D Search structures
- additional range search operations taking a predicate functor
Support Library:
Qt_widget
- We have added a new class for visualization of 2D CGAL objects.
It is derived from Trolltech's Qt class QWidget. This code is
distributed under a dual QPL and commercial license.
- Some demos were developed for the following packages: 2D Alpha shapes,
2D Convex Hull, Largest empty 2D rectangle, Maximum k-gon,
Minimum ellipse, Minimum 2D quadrilateral, 2D polygon partitioning
2D regular and constrained triangulation.
- Tutorials are available to help users get used to Qt_widget.
Timer
- Fixed Timer class (for user process time) to have no wrap-around
anymore on Posix-compliant systems.
The following functionality is no longer supported:
- Planar maps of infinite curves (the so-called planar map bounding-box).
Bugs in the following packages have been fixed:
3D Convex hull, 2D Polygon partition, simple polygon generator,
2D intersections
Also, attempts have been made to assure compatibility with upcoming LEDA
releases that introduce the leda namespace.
Known problems:
- 2D Nef Polyhedra contains a memory leak. Memory problems are also
the likely cause of occasional run-time errors on some platforms.
- The d-dimensional convex hull computation produces run-time errors on
some platforms because of memory management bugs.
- The new Halfedge Data Structure design introduced with release 2.3
does not work on VC6. See the release notes in the manual for more
information.
- The following deficiencies relate to planar maps, planar maps of
intersecting curves (pmwx), arrangements and sweep line.
- On KCC, Borland and SunPro we guarantee neither compilation nor
correct execution for all of the packages above.
- On VC6 and VC7 we guarantee neither compilation nor correct
execution of the sweep line package.
- On CC (on Irix 6.5) the trapezoidal decomposition point location
strategy is problematic when used with planar maps, pmwx, or
arrangements (mind that this is the default for planar maps).
- On CC (on Irix 6.5) sweep line with polyline traits does not compile
(mind that the so-called leda polyline traits does compile).
- On g++ (on Irix 6.5) the segment-circle (Arr_segment_circle_traits_2)
traits does not compile for any of the above packages.
----------------------------- Release 2.3 ------------------------------------
Version 2.3 differs from version 2.2 in the platforms that are supported and
in functionality.
Additional supported platforms:
Gnu g++ 3.0 on Solaris, Linux
The following functionality has been added:
Kernels:
- The 2D and 3D kernels now serve as models of the new kernel concept
described in the recent paper, "An Adaptable and Extensible Geometry
Kernel" by Susan Hert, Michael Hoffmann, Lutz Kettner, Sylvain Pion,
and Michael Seel to be presented at WAE 2001 (and soon available as
a technical report). This new kernel is completely compatible with
the previous design but is more flexible in that it allows geometric
predicates as well as objects to be easily exchanged and adapted
individually to users' needs.
- A new kernel called Simple_homogeneous<> is available. It is equivalent
to Homogeneous<> but without reference-counted objects.
- A new kernel called Filtered_kernel<> is available that allows one to
build kernel traits classes that use exact and efficient predicates.
- There are two classes, Cartesian_converter<> and Homogeneous_converter
that allows one to convert objects between different Cartesian and
homogeneous kernels, respectively.
- A new d-dimensional kernel, Kernel_d is available. It provides diverse
kernel objects, predicates and constructions in d dimensions with two
representations based on the kernel families Cartesian_d and Homogeneous_d
Basic Library:
Almost all packages in the basic library have been adapted to the
new kernel design to realize the flexibility this design makes possible.
In several packages, this means that the traits class requirements have
changed to conform to the function objects offered in the kernels so the
kernels themselves can be used as traits classes in many instances.
2D Convex Hull
- The traits requirements have changed slightly.
3D Convex Hull
- The convex_hull_3 function now uses a new implementation of the
quickhull algorithm that no longer requires LEDA.
- A new convex_hull_incremental_3 function based on the new d-dimensional
convex hull class is available for comparison purposes
Convex_hull_d, Delaunay_d
Two new application classes offering the calculation of d-dimensional
convex hulls and delaunay triangulations
Polygon
- The traits class requirements have been changed.
- The simplicity test has a completely new implementation.
- Properties like convexity, simplicity and area can now be cached by
polygons. You need to set a flag to select this behavior.
Planar Nef Polyhedra
A new class (Nef_polyhedron_2) representing planar Nef polyhedra =
rectilinearly bounded points sets that are the result of binary and
topological operations starting from halfplanes.
Planar Polygon Partitioning
New package offering functions to partition planar polygons into
convex and y-monotone pieces.
Planar Maps and Arrangements
- A new class Planar_map_with_intersections_2<Planar_map> for planar maps
of possibly intersecting, possibly non-x-monotone, possibly overlapping
curves (like Arrangement_2 but without the hierarchy tree).
- I/O utilities for planar maps and arrangements for textual and
graphical streams. (It is possible to save and later reload built
planar maps or arrangements.)
- New arrangement traits class for line segments and circular arcs
(Arr_segment_circle_traits<NT>).
- New faster traits for polylines specialized for using the LEDA
rational kernel (Arr_leda_polylines_traits). The LEDA traits for
segments was also made faster.
- A new point location strategy (Pm_simple_point_location<Planar_map>).
Halfedge Data Structure
The halfedge data structure has been completely revised. The new design
is more in line with the STL naming scheme and it provides a safe and
coherent type system throughout the whole design (no void* pointers
anymore), which allows for better extendibility. A user can add new
incidences in the mesh easily. The new design also uses standard
allocators with a new template parameter that has a suitable default.
The old design is still available, but its use is deprecated, see the
manual of deprecated packages for its documentation. Reported bugs in
copying the halfedge data structure (and therefore also polyhedral
surfaces) have been fixed in both designs. Copying a list based
representation is now based on hash maps instead of std::map and
therefore considerably faster.
Polyhedral Surface
The polyhedral surface has been rewritten to work with the new
halfedge data structure design. The user level interface of the
CGAL::Polyhedron_3 class is almost backwards compatible with the
previous class. The exceptions are the template parameter list,
everything that relies on the flexibility of the underlying
halfedge data structure, such as a self written facet class, and
that the distinction between supported normals and supported planes
has been removed. Only planes are supported. See the manuals for
suggestions how to handle normals instead of planes.
More example programs are provided with polyhedral surfaces,
for example, one about Euler operator and one computing a subdivision
surface given a control mesh as input.
The old design is still available for backwards compatibility and to
support older compiler, such as MSVC++6.0. For the polyhedral surface,
old and new design cannot be used simultaneously (they have identical
include file names and class names). The include files select
automatically the old design for MSVC++6.0 and the new design
otherwise. This automatism can be overwritten by defining appropriate
macros before the include files. The old design is selected with the
CGAL_USE_POLYHEDRON_DESIGN_ONE macro. The new design is selected with
the CGAL_USE_POLYHEDRON_DESIGN_TWO macro.
2D Triangulation
The geometric traits class requirements have been changed to conform
to the new CGAL kernels. CGAL kernel classes can be used as traits
classes for all 2D triangulations except for regular triangulations.
Additional functionality:
- dual method for regular triangulations (to build a power diagram)
- unified names and signatures for various "find_conflicts()"
member functions in Delaunay and constrained Delaunay triangulation.
- As an alternative to the simple insert() member function,
insertion of points in those triangulation can be performed using the
combination of find_conflicts() and star_hole() which eventually
allows the user to keep track of deleted faces.
More demos and examples
3D Triangulation
Major improvements
- A new class Triangulation_hierarchy_3 that allows a faster point
location, and thus construction of the Delaunay triangulation
- A new method for removing a vertex from a Delaunay triangulation
that solves all degenerate cases
- Running time of the usual location and insertion methods improved
A bit more functionality, such as
- New geomview output
- dual methods in Delaunay triangulations to draw the Voronoi diagram
More demos and examples
Changes in interface
- Traits classes requirements have been modified
- The kernel can be used directly as a traits class (except for
regular triangulation)
- insert methods in Triangulation_data_structure have a new interface
3D Alpha shapes
A new class (Alpha_shapes_3) that computes Alpha shapes of point sets
in 3D is available.
Geometric Optimisation
The traits requirements for Matrix_search and Min_quadrilateral_2
have been changed to bring them in line with the CGAL kernels.
Point_set_2
- now independent of LEDA, based on the CGAL Delaunay triangulation and
converted to kernel traits
- function template versions of the provided query operations
Support Library:
----------------
In_place_list has a new third template parameter
(with a suitable default) for an STL-compliant allocator.
Unique_hash_map is a new support class.
Geomview_stream :
- Geomview version 1.8.1 is now required.
- no need to have a ~/.geomview file anymore.
- new output operators for triangulations.
- new output operators for Ray_2, Line_2, Ray_3, Line_3, Sphere_3.
- various new manipulators.
Number types :
- Lazy_exact_nt<NT> is a new number type wrapper to speed up exact
number types.
- MP_Float is a new multi-precision floating point number type. It can
do exact additions, subtractions and multiplications over
floating point values.
Window stream
In cooperation with Algorithmic Solutions, GmbH (distributors of
the LEDA library), we can now offer a visualization package
downloadable in binary form that support visualization on a ported
version of the LEDA window lib.
----------------------------- Release 2.2 ------------------------------------
Version 2.2 differs from version 2.2 in the platforms that are supported and
in functionality.
Additional supported platforms:
- the KAI compiler (4.0) on Solaris 5.8
- Borland C++ (5.5)
The following functionality has been added:
- There is a new, non-reference-counted kernel, Simple_cartesian. Because
reference counting is not used, and thus coordinates are stored within a
class, debugging is easier using this kernel. This kernel can also be
faster in some cases than the reference-counted Cartesian kernel.
- New optimisation algorithms:
-- Min_annulus_d - Algorithm for computing the smallest enclosing
annulus of points in arbitrary dimension
-- Polytope_distance_d - Algorithm for computing the (squared)
distance between two convex polytopes in arbitrary dimension
-- Width_3 - Algorithm for computing the (squared) width of points
sets in three dimensions
- 2D Triangulations
-- There are now two triangulation data structures available in CGAL.
The new one uses a list to store the faces and allows one to
represent two-dimensional triangulations embedded in three spaces
as well as planar triangulations.
-- The triangulation hierarchy which allows fast location query
is now available.
- Infinite objects can now be included in planar maps.
- Removal as well as insertions of vertices for 3D Delaunay triangulations
is now possible.
- A generator for ``random'' simple polygons is now available.
- In directory demo/Robustness, programs that demonstrate typical robustness
problems in geometric computing are presented along with the solutions to
these problems that CGAL provides.
The following functionality has been removed:
-- The binary operations on polygons (union, intersection ...) have been
removed since the code could not be adapted to all supported
platforms. Arrangements can often be used as a substitute.
--------------------------------- Release 2.1 --------------------------------
Version 2.1 differs from version 2.0 in the platforms that are supported and
in functionality.
Supported platforms:
- the newest gnu compiler (2.95.2) on Sun, SGI, Linux and Windows.
- the Microsoft Visual C++ compiler, version 6.
- the mips CC compiler version 7.3 under Irix.
Support for the old g++ compiler (2.8) and for mips CC 7.2 has been dropped.
The following functionality has been added:
- Alpha shapes and weighted alpha shapes in 2D. Alpha shapes are a
generalization of the convex hull of a point set.
- Arrangements in 2D. Arrangements are related to and based on planar maps.
The major difference between the two is that curves are allowed to
intersect in the case of arrangements.
- Extensions to triangulations in 2D. Constrained triangulations are now
dynamic: they support insertions of new constraint as well as removal of
existing constraints. There are also constrained Delaunay triangulations.
- Triangulations in 3D were added, both Delaunay triangulations and regular
triangulations.
- Min_quadrilateral optimisations have been added. These are algorithms to
compute the minimum enclosing rectangle/parallelogram (arbitrary
orientation) and the minimum enclosing strip of a convex point set.
- 2d Point_set is a package for 2d range search operations, Delaunay
triangulation, nearest neighbor queries. This package works only if
LEDA is installed.
- Support for GeoWin visualization library. This also depends on LEDA.
- Support for using the CLN number type together with CGAL.
----------------------------- Release 2.0 ------------------------------------
The main difference from release 1.2 is the introduction of namespaces --
namespace std for code from the standard library and namespace CGAL for
the CGAL library.
----------------------------- Release 1.2 ------------------------------------
Additions to release 1.1 include:
- topological map
- planar map overlay
- regular and constrained triangulations
----------------------------- Release 1.1 ------------------------------------
Additions to release 1.0 include:
- 3D intersections
- kD points
- 3D convex hull
- kD smallest enclosing sphere
----------------------------- Release 1.0 ------------------------------------
Additions to release 0.9 include:
- Polyhedral surfaces
- Halfedge Data Structure
- Planar maps
----------------------------- Release 0.9 ------------------------------------
Initial (beta) release of the CGAL library.
------------------------------------------------------------------------------
Reference in New Issue View Git Blame Copy Permalink