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

Add a base configuration and the default manuals from the old branch

This commit is contained in:
Philipp Möller 2012-06-04 13:55:22 +00:00
parent c7e83a401b
commit 71a48a31a9
11 changed files with 4844 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
.gitattributes vendored
View File

@ -1463,6 +1463,16 @@ Developers_manual/doc_tex/Developers_manual/fig/use_real.pdf -text svneol=unset#
Documentation/Installation.txt -text
Documentation/Introduction.txt -text
Documentation/Preliminaries.txt -text
Documentation/doc/Doxyfile -text
Documentation/doc/DoxygenLayout.xml -text
Documentation/doc/Installation.txt -text
Documentation/doc/Introduction.txt -text
Documentation/doc/Preliminaries.txt -text
Documentation/doc/cgal_manual.bib -text
Documentation/doc/footer.html -text
Documentation/doc/header.html -text
Documentation/doc/main.txt -text
Documentation/doc/stylesheet.css -text
Envelope_2/doc_tex/Envelope_2/fig/Envelope_2.png -text
Envelope_2/doc_tex/Envelope_2/fig/ex_circle.fig -text svneol=unset#application/octet-stream
Envelope_2/doc_tex/Envelope_2/fig/ex_circle.gif -text svneol=unset#image/gif

420
Documentation/doc/Doxyfile Normal file
View File

@ -0,0 +1,420 @@
# Doxyfile 1.8.0
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
DOXYFILE_ENCODING = UTF-8
PROJECT_NAME = CGAL 4.1
PROJECT_NUMBER =
PROJECT_BRIEF =
PROJECT_LOGO = cgal_logo.gif
OUTPUT_DIRECTORY =
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ABBREVIATE_BRIEF = "The $name class" \
"The $name widget" \
"The $name file" \
is \
provides \
specifies \
contains \
represents \
a \
an \
the
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = NO
STRIP_FROM_PATH =
STRIP_FROM_INC_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = YES
QT_AUTOBRIEF = YES
MULTILINE_CPP_IS_BRIEF = NO
INHERIT_DOCS = YES
SEPARATE_MEMBER_PAGES = NO
TAB_SIZE = 8
ALIASES += sc{1}="<span style=\"font-variant: small-caps;\">\1</span>"
ALIASES += cgal="*CGAL*"
ALIASES += stl="*STL*"
ALIASES += gcc="*GCC*"
ALIASES += CC="*C++*"
ALIASES += cgalexample{1}="\include \1"
ALIASES += cgalbib{1}="<dl class=\"section\"><dt>BibTeX:</dt><dd>\cite \1</dd></dl>"
ALIASES += license{1}="<dl class=\"section\"><dt>License:</dt><dd>\1</dd></dl>"
ALIASES += "models=\xrefitem modelss \"Models\" \"Models\""
ALIASES += "refines=\xrefitem refiness \"Refines\" \"Refines\""
ALIASES += "hasModels=\xrefitem asModelss \"Has Models\" \"Has Models\""
ALIASES += "advanced=\xrefitem advanceds \"Advanced\" \"Advanced\""
ALIASES += "debug=\xrefitem debugs \"Debug\" \"Debug\""
ALIASES += beginadvanced=""
ALIASES += endadvanced=""
TCL_SUBST =
OPTIMIZE_OUTPUT_FOR_C = NO
OPTIMIZE_OUTPUT_JAVA = NO
OPTIMIZE_FOR_FORTRAN = NO
OPTIMIZE_OUTPUT_VHDL = NO
EXTENSION_MAPPING =
BUILTIN_STL_SUPPORT = YES
CPP_CLI_SUPPORT = NO
SIP_SUPPORT = NO
IDL_PROPERTY_SUPPORT = YES
DISTRIBUTE_GROUP_DOC = NO
SUBGROUPING = YES
INLINE_GROUPED_CLASSES = NO
INLINE_SIMPLE_STRUCTS = NO
TYPEDEF_HIDES_STRUCT = NO
SYMBOL_CACHE_SIZE = 0
LOOKUP_CACHE_SIZE = 0
#---------------------------------------------------------------------------
# Build related configuration options
#---------------------------------------------------------------------------
EXTRACT_ALL = YES
EXTRACT_PRIVATE = NO
EXTRACT_STATIC = YES
EXTRACT_LOCAL_CLASSES = YES
EXTRACT_LOCAL_METHODS = NO
EXTRACT_ANON_NSPACES = NO
HIDE_UNDOC_MEMBERS = NO
HIDE_UNDOC_CLASSES = NO
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = NO
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
FORCE_LOCAL_INCLUDES = NO
INLINE_INFO = NO
SORT_MEMBER_DOCS = YES
SORT_BRIEF_DOCS = NO
SORT_MEMBERS_CTORS_1ST = NO
SORT_GROUP_NAMES = NO
SORT_BY_SCOPE_NAME = NO
STRICT_PROTO_MATCHING = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = NO
GENERATE_BUGLIST = NO
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 30
SHOW_USED_FILES = YES
SHOW_FILES = YES
SHOW_NAMESPACES = YES
FILE_VERSION_FILTER =
LAYOUT_FILE =
CITE_BIB_FILES = cgal_manual.bib
#---------------------------------------------------------------------------
# configuration options related to warning and progress messages
#---------------------------------------------------------------------------
QUIET = NO
WARNINGS = YES
WARN_IF_UNDOCUMENTED = YES
WARN_IF_DOC_ERROR = YES
WARN_NO_PARAMDOC = NO
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = ../../Algebraic_foundations/doc/Algebraic_foundations \
.
# ../../AABB_tree/doc/AABB_tree \
# ../../Algebraic_kernel_d/doc/Algebraic_kernel_d \
# ../../Algebraic_kernel_for_circles/doc/Algebraic_kernel_for_circles \
# ../../Alpha_shapes_2/doc/Alpha_shapes_2 \
# ../../Alpha_shapes_3/doc/Alpha_shapes_3 \
# ../../Apollonius_graph_2/doc/Apollonius_graph_2 \
# ../../Approximate_min_ellipsoid_d/doc/Approximate_min_ellipsoid_d \
# ../../Arrangement_on_surface_2/doc/Arrangement_on_surface_2 \
# ../../BGL/doc/BGL \
# ../../Boolean_set_operations_2/doc/Boolean_set_operations_2 \
# ../../Box_intersection_d/doc/Box_intersection_d \
# ../../CGAL_ipelets/doc/CGAL_ipelets \
# ../../Circular_kernel_2/doc/Circular_kernel_2 \
# ../../Circular_kernel_3/doc/Circular_kernel_3 \
# ../../Circulator/doc/Circulator \
# ../../Combinatorial_map/doc/Combinatorial_map \
# ../../Convex_decomposition_3/doc/Convex_decomposition_3 \
# ../../Convex_hull_2/doc/Convex_hull_2 \
# ../../Convex_hull_3/doc/Convex_hull_3 \
# ../../Convex_hull_d/doc/Convex_hull_d \
# ../../Developers_manual/doc/Developers_manual \
# ../../Envelope_2/doc/Envelope_2 \
# ../../Envelope_3/doc/Envelope_3 \
# ../../Generator/doc/Generator \
# ../../Geomview/doc/Geomview \
# ../../GraphicsView/doc/GraphicsView \
# ../../HalfedgeDS/doc/HalfedgeDS \
# ../../Hash_map/doc/Hash_map \
# ../../Installation/doc/Installation \
# ../../Interpolation/doc/Interpolation \
# ../../Interval_skip_list/doc/Interval_skip_list \
# ../../iostream/doc/iostream \
# ../../Jet_fitting_3/doc/Jet_fitting_3 \
# ../../Kernel_23/doc/Kernel_23 \
# ../../Kernel_d/doc/Kernel_d \
# ../../Kinetic_data_structures/doc/Kinetic_data_structures \
# ../../Largest_empty_rect_2/doc/Largest_empty_rect_2 \
# ../../Linear_cell_complex/doc/Linear_cell_complex \
# ../../Manual/doc/Manual \
# ../../Manual_tools/doc/Manual_tools \
# ../../Matrix_search/doc/Matrix_search \
# ../../Mesh_2/doc/Mesh_2 \
# ../../Mesh_3/doc/Mesh_3 \
# ../../Min_annulus_d/doc/Min_annulus_d \
# ../../Min_circle_2/doc/Min_circle_2 \
# ../../Min_ellipse_2/doc/Min_ellipse_2 \
# ../../Minkowski_sum_2/doc/Minkowski_sum_2 \
# ../../Minkowski_sum_3/doc/Minkowski_sum_3 \
# ../../Min_quadrilateral_2/doc/Min_quadrilateral_2 \
# ../../Min_sphere_d/doc/Min_sphere_d \
# ../../Min_sphere_of_spheres_d/doc/Min_sphere_of_spheres_d \
# ../../Modifier/doc/Modifier \
# ../../Modular_arithmetic/doc/Modular_arithmetic \
# ../../Nef_2/doc/Nef_2 \
# ../../Nef_3/doc/Nef_3 \
# ../../Nef_S2/doc/Nef_S2 \
# ../../Number_types/doc/Number_types \
# ../../Optimisation_basic/doc/Optimisation_basic \
# ../../Optimisation_doc/doc/Optimisation_doc \
# ../../Partition_2/doc/Partition_2 \
# ../../Periodic_3_triangulation_3/doc/Periodic_3_triangulation_3 \
# ../../Point_set_2/doc/Point_set_2 \
# ../../Point_set_processing_3/doc/Point_set_processing_3 \
# ../../Polygon/doc/Polygon \
# ../../Polyhedron/doc/Polyhedron \
# ../../Polynomial/doc/Polynomial \
# ../../Polytope_distance_d/doc/Polytope_distance_d \
# ../../Principal_component_analysis/doc/Principal_component_analysis \
# ../../Profiling_tools/doc/Profiling_tools \
# ../../QP_solver/doc/QP_solver \
# ../../Qt_widget/doc/Qt_widget \
# ../../Random_numbers/doc/Random_numbers \
# ../../Ridges_3/doc/Ridges_3 \
# ../../SearchStructures/doc/SearchStructures \
# ../../Segment_Delaunay_graph_2/doc/Segment_Delaunay_graph_2 \
# ../../Skin_surface_3/doc/Skin_surface_3 \
# ../../Snap_rounding_2/doc/Snap_rounding_2 \
# ../../Spatial_searching/doc/Spatial_searching \
# ../../Spatial_sorting/doc/Spatial_sorting \
# ../../STL_Extension/doc/STL_Extension \
# ../../Straight_skeleton_2/doc/Straight_skeleton_2 \
# ../../Stream_lines_2/doc/Stream_lines_2 \
# ../../Stream_support/doc/Stream_support \
# ../../Subdivision_method_3/doc/Subdivision_method_3 \
# ../../Surface_mesher/doc/Surface_mesher \
# ../../Surface_mesh_parameterization/doc/Surface_mesh_parameterization \
# ../../Surface_mesh_simplification/doc/Surface_mesh_simplification \
# ../../Surface_reconstruction_points_3/doc/Surface_reconstruction_points_3 \
# ../../Triangulation_2/doc/Triangulation_2 \
# ../../Triangulation_3/doc/Triangulation_3 \
# ../../Union_find/doc/Union_find \
# ../../Voronoi_diagram_2/doc/Voronoi_diagram_2 \
# ../../Width_3/doc/Width_3 \
.
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.h \
*.txt
RECURSIVE = YES
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXCLUDE_SYMBOLS =
EXAMPLE_PATH =
EXAMPLE_PATTERNS = *
EXAMPLE_RECURSIVE = NO
IMAGE_PATH = ../../Algebraic_foundations/doc/Algebraic_foundations/fig
INPUT_FILTER =
FILTER_PATTERNS =
FILTER_SOURCE_FILES = NO
FILTER_SOURCE_PATTERNS =
#---------------------------------------------------------------------------
# configuration options related to source browsing
#---------------------------------------------------------------------------
SOURCE_BROWSER = NO
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = NO
REFERENCES_RELATION = NO
REFERENCES_LINK_SOURCE = YES
USE_HTAGS = NO
VERBATIM_HEADERS = YES
#---------------------------------------------------------------------------
# configuration options related to the alphabetical class index
#---------------------------------------------------------------------------
ALPHABETICAL_INDEX = YES
COLS_IN_ALPHA_INDEX = 5
IGNORE_PREFIX =
#---------------------------------------------------------------------------
# configuration options related to the HTML output
#---------------------------------------------------------------------------
GENERATE_HTML = YES
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER = header.html
HTML_FOOTER = footer.html
HTML_STYLESHEET = stylesheet.css
HTML_EXTRA_FILES =
HTML_COLORSTYLE_HUE = 60
HTML_COLORSTYLE_SAT = 180
HTML_COLORSTYLE_GAMMA = 78
HTML_TIMESTAMP = YES
HTML_DYNAMIC_SECTIONS = YES
GENERATE_DOCSET = NO
DOCSET_FEEDNAME = "Doxygen generated docs"
DOCSET_BUNDLE_ID = org.doxygen.Project
DOCSET_PUBLISHER_ID = org.doxygen.Publisher
DOCSET_PUBLISHER_NAME = Publisher
GENERATE_HTMLHELP = NO
CHM_FILE =
HHC_LOCATION =
GENERATE_CHI = NO
CHM_INDEX_ENCODING =
BINARY_TOC = NO
TOC_EXPAND = NO
GENERATE_QHP = NO
QCH_FILE =
QHP_NAMESPACE = org.doxygen.Project
QHP_VIRTUAL_FOLDER = doc
QHP_CUST_FILTER_NAME =
QHP_CUST_FILTER_ATTRS =
QHP_SECT_FILTER_ATTRS =
QHG_LOCATION =
GENERATE_ECLIPSEHELP = NO
ECLIPSE_DOC_ID = org.doxygen.Project
DISABLE_INDEX = NO
GENERATE_TREEVIEW = NO
ENUM_VALUES_PER_LINE = 4
TREEVIEW_WIDTH = 250
EXT_LINKS_IN_WINDOW = NO
FORMULA_FONTSIZE = 10
FORMULA_TRANSPARENT = YES
USE_MATHJAX = YES
MATHJAX_RELPATH = http://www.mathjax.org/mathjax
MATHJAX_EXTENSIONS =
SEARCHENGINE = YES
SERVER_BASED_SEARCH = NO
#---------------------------------------------------------------------------
# configuration options related to the LaTeX output
#---------------------------------------------------------------------------
GENERATE_LATEX = NO
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = a4
EXTRA_PACKAGES =
LATEX_HEADER =
LATEX_FOOTER =
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
LATEX_SOURCE_CODE = NO
LATEX_BIB_STYLE = plain
#---------------------------------------------------------------------------
# configuration options related to the RTF output
#---------------------------------------------------------------------------
GENERATE_RTF = NO
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
#---------------------------------------------------------------------------
# configuration options related to the man page output
#---------------------------------------------------------------------------
GENERATE_MAN = NO
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_LINKS = NO
#---------------------------------------------------------------------------
# configuration options related to the XML output
#---------------------------------------------------------------------------
GENERATE_XML = NO
XML_OUTPUT = xml
XML_SCHEMA =
XML_DTD =
XML_PROGRAMLISTING = NO
#---------------------------------------------------------------------------
# configuration options for the AutoGen Definitions output
#---------------------------------------------------------------------------
GENERATE_AUTOGEN_DEF = NO
#---------------------------------------------------------------------------
# configuration options related to the Perl module output
#---------------------------------------------------------------------------
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
#---------------------------------------------------------------------------
# Configuration options related to the preprocessor
#---------------------------------------------------------------------------
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED =
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
#---------------------------------------------------------------------------
# Configuration::additions related to external references
#---------------------------------------------------------------------------
TAGFILES =
GENERATE_TAGFILE =
ALLEXTERNALS = YES
EXTERNAL_GROUPS = YES
PERL_PATH = /usr/bin/perl
#---------------------------------------------------------------------------
# Configuration options related to the dot tool
#---------------------------------------------------------------------------
CLASS_DIAGRAMS = YES
MSCGEN_PATH =
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = YES
DOT_NUM_THREADS = 0
DOT_FONTNAME = Helvetica
DOT_FONTSIZE = 10
DOT_FONTPATH =
CLASS_GRAPH = YES
COLLABORATION_GRAPH = NO
GROUP_GRAPHS = NO
UML_LOOK = NO
TEMPLATE_RELATIONS = YES
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
CALLER_GRAPH = NO
GRAPHICAL_HIERARCHY = YES
DIRECTORY_GRAPH = YES
DOT_IMAGE_FORMAT = png
INTERACTIVE_SVG = YES
DOT_PATH =
DOTFILE_DIRS =
MSCFILE_DIRS =
DOT_GRAPH_MAX_NODES = 50
MAX_DOT_GRAPH_DEPTH = 0
DOT_TRANSPARENT = NO
DOT_MULTI_TARGETS = NO
GENERATE_LEGEND = YES
DOT_CLEANUP = YES

191
Documentation/doc/DoxygenLayout.xml Normal file
View File

@ -0,0 +1,191 @@
<doxygenlayout version="1.0">
<!-- Navigation index tabs for HTML output -->
<navindex>
<tab type="user" url="@ref packages" title="Packages"/>
<tab type="mainpage" visible="yes" title=""/>
<!-- <tab type="pages" visible="yes" title="" intro=""/> -->
<tab type="modules" visible="yes" title="" intro=""/>
<tab type="namespaces" visible="yes" title="">
<tab type="namespacelist" visible="yes" title="" intro=""/>
<tab type="namespacemembers" visible="yes" title="" intro=""/>
</tab>
<tab type="classes" visible="yes" title="">
<tab type="classlist" visible="yes" title="" intro=""/>
<tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
<tab type="hierarchy" visible="yes" title="" intro=""/>
<tab type="classmembers" visible="yes" title="" intro=""/>
</tab>
<tab type="files" visible="yes" title="">
<tab type="filelist" visible="yes" title="" intro=""/>
<tab type="globals" visible="yes" title="" intro=""/>
</tab>
<tab type="examples" visible="yes" title="" intro=""/>
</navindex>
<!-- Layout definition for a class page -->
<class>
<briefdescription visible="no"/>
<detaileddescription title=" "/>
<includes visible="$SHOW_INCLUDE_FILES"/>
<inheritancegraph visible="$CLASS_GRAPH"/>
<collaborationgraph visible="$COLLABORATION_GRAPH"/>
<allmemberslink visible="yes"/>
<memberdecl>
<nestedclasses visible="yes" title=""/>
<!-- Disable the naming of the public types group -->
<publictypes title=" "/>
<publicslots title=""/>
<signals title=""/>
<publicmethods title=""/>
<publicstaticmethods title=""/>
<publicattributes title=""/>
<publicstaticattributes title=""/>
<protectedtypes title=""/>
<protectedslots title=""/>
<protectedmethods title=""/>
<protectedstaticmethods title=""/>
<protectedattributes title=""/>
<protectedstaticattributes title=""/>
<packagetypes title=""/>
<packagemethods title=""/>
<packagestaticmethods title=""/>
<packageattributes title=""/>
<packagestaticattributes title=""/>
<properties title=""/>
<events title=""/>
<privatetypes title=""/>
<privateslots title=""/>
<privatemethods title=""/>
<privatestaticmethods title=""/>
<privateattributes title=""/>
<privatestaticattributes title=""/>
<friends title=""/>
<related title="" subtitle=""/>
<membergroups visible="yes"/>
</memberdecl>
<memberdef>
<inlineclasses title=""/>
<typedefs title=""/>
<enums title=""/>
<constructors title=""/>
<functions title=""/>
<related title=""/>
<variables title=""/>
<properties title=""/>
<events title=""/>
</memberdef>
<usedfiles visible="$SHOW_USED_FILES"/>
<authorsection visible="yes"/>
</class>
<!-- Layout definition for a namespace page -->
<namespace>
<briefdescription visible="yes"/>
<memberdecl>
<nestednamespaces visible="yes" title=""/>
<classes visible="yes" title=""/>
<typedefs title=""/>
<enums title=""/>
<functions title=""/>
<variables title=""/>
<membergroups visible="yes"/>
</memberdecl>
<detaileddescription title=""/>
<memberdef>
<inlineclasses title=""/>
<typedefs title=""/>
<enums title=""/>
<functions title=""/>
<variables title=""/>
</memberdef>
<authorsection visible="yes"/>
</namespace>
<!-- Layout definition for a file page -->
<file>
<briefdescription visible="yes"/>
<includes visible="$SHOW_INCLUDE_FILES"/>
<includegraph visible="$INCLUDE_GRAPH"/>
<includedbygraph visible="$INCLUDED_BY_GRAPH"/>
<sourcelink visible="yes"/>
<memberdecl>
<classes visible="yes" title=""/>
<namespaces visible="yes" title=""/>
<defines title=""/>
<typedefs title=""/>
<enums title=""/>
<functions title=""/>
<variables title=""/>
<membergroups visible="yes"/>
</memberdecl>
<detaileddescription title=""/>
<memberdef>
<inlineclasses title=""/>
<defines title=""/>
<typedefs title=""/>
<enums title=""/>
<functions title=""/>
<variables title=""/>
</memberdef>
<authorsection/>
</file>
<!-- Layout definition for a group page -->
<group>
<detaileddescription title=" "/>
<authorsection visible="yes"/>
<groupgraph visible="$GROUP_GRAPHS"/>
<memberdef>
<pagedocs/>
</memberdef>
<memberdecl>
<nestedgroups visible="yes" title=""/>
<dirs visible="yes" title=""/>
<files visible="yes" title=""/>
<namespaces visible="yes" title=""/>
<classes visible="yes" title=""/>
<defines title=""/>
<typedefs title=""/>
<enums title=""/>
<enumvalues title=""/>
<functions title=""/>
<variables title=""/>
<signals title=""/>
<publicslots title=""/>
<protectedslots title=""/>
<privateslots title=""/>
<events title=""/>
<properties title=""/>
<friends title=""/>
<membergroups visible="yes"/>
</memberdecl>
<memberdef>
<inlineclasses title=""/>
<defines title=""/>
<typedefs title=""/>
<enums title=""/>
<enumvalues title=""/>
<functions title=""/>
<variables title=""/>
<signals title=""/>
<publicslots title=""/>
<protectedslots title=""/>
<privateslots title=""/>
<events title=""/>
<properties title=""/>
<friends title=""/>
</memberdef>
</group>
<!-- Layout definition for a directory page -->
<directory>
<briefdescription visible="yes"/>
<directorygraph visible="yes"/>
<memberdecl>
<dirs visible="yes"/>
<files visible="yes"/>
</memberdecl>
<detaileddescription title=""/>
</directory>
</doxygenlayout>

8
Documentation/doc/Installation.txt Normal file
View File

@ -0,0 +1,8 @@
/*!
\page installation Installation
\author CGAL Editorial Board
*/

163
Documentation/doc/Introduction.txt Normal file
View File

@ -0,0 +1,163 @@
/*!
\page introduction Introduction
\author CGAL Editorial Board
The goal of the \cgal Open Source Project is to provide *easy access
to efficient and reliable geometric algorithms* in the form of a C++
library.
The Computational Geometry Algorithms Library offers data structures
and algorithms like triangulations, Voronoi diagrams, Boolean
operations on polygons and on polyhedra, arrangements of curves, mesh
generation, geometry processing, convex hull algorithms, to name just
a few.
All these data structures and algorithms operate on geometric objects
like points and segments, and perform geometric tests on them.
These objects and predicates are regrouped in \cgal *Kernels*.
Finally, the \cgal *Support Library* offers geometric object
generators and spatial sorting functions, as well as a matrix search
framework and a solver for linear and quadratic programs. It further
offers interfaces to third party software such as the *Gui* libraries
Qt, Geomview, and the Boost Graph Library.
Organization of the Manual
==========================
This manual is organized in several parts covering the many domains
of computational geometry. Each part consists of several chapters,
and each chapter is split into a *user manual* and a *reference
manual*. The user manual gives the general idea and comes with examples.
The reference manual presents the **Api** of the various classes
and functions.
The manual has a table of contents, and an index, as well as a package overview,
which gives a short paragraph what the package is about, what license
it has, and on which other packages it depends. It further provides
links to precompiled demo programs for the Windows platform.
Demos and Examples
==================
In the distribution of the library you find the two directories *demo*
and *examples*. They contain subdirectories for the \cgal packages.
The demos use third party libraries for the graphical user interface. The
examples don't have this dependency and most examples are refered to in the
user manual.
Hello World
===========
In this section we will take a closer look at three \cgal example
programs, all of them computing the 2D convex hull of a set of points.
Points in a built-in array
--------------------------
In the first example we have an array of five points.
As the convex hull of these points is a subset of the input
it is safe to provide an array for storing the result which
has the same size.
\cgalexample{Convex_hull_2/array_convex_hull_2.cpp}
All \cgal header files are in the subdirectory ``include/CGAL''. All \cgal
classes and functions are in the namespace ``CGAL''. The geometric
primitives, like the point type, are defined in a kernel. \cgal comes
with several kernels, and as the convex hull algorithm only makes
comparisons of coordinates and orientation tests of input points,
we can choose a kernel that provides exact predicates, but no
exact geometric construction.
The convex hull function takes three arguments, the start
and past-the-end pointer for the input, and the start pointer of the
array for the result. The function returns the pointer
into the result array just behind the last convex hull
point written, so the pointer difference tells us how
many points are on the convex hull.
Points in a STL vector
----------------------
In the second example we replace the built-in array
by a `std::vector` of the Standard Template Library.
\cgalexample{Convex_hull_2/vector_convex_hull_2.cpp}
We put some points in the vector calling the `push_back()`
method of the `std::vector` class.
We then call the convex hull function. The first two arguments,
`points.begin()} and `points.end()` are *iterators*, which are a
generalization of pointers: they can be dereferenced and
incremented. The convex hull function is *generic* in the sense
that it takes as input whatever can be dereferenced and incremented.
The third argument is where the result gets written to. In the
previous example we provided a pointer to allocated memory. The
generalization of such a pointer is the *output iterator*, which
allows to increment and assign a value to the dereferenced iterator.
In this example we start with an empty vector which grows as needed.
Therefore, we cannot simply pass it `result.begin()`, but an output
iterator generated by the helper function
`std::back_inserter(result)`. This output iterator does nothing when
incremented, and calls `result.push_back(..)` on the assignment.
Points in Streams
-----------------
The last example program reads a sequence of points from standard
input `std::cin` and writes the points on the convex hull to standard
output `std::cout`.
Instead of storing the points in a container such as an `std::vector`,
and passing the begin/end iterator of the vector to the convex hull
function, we use helper classes that turn file pointers into
iterators.
\cgalexample{Convex_hull_2/iostream_convex_hull_2.cpp}
In the example code you see input and output stream iterators
templated with the point type. A `std::istream_iterator<Point_2>`
hence allows to traverse a sequence of objects of type `Point_2`, which
come from standard input as we pass `std::cin` to the
constructor of the iterator. The variable `input_end` denotes
end-of-file.
A `std::ostream_iterator<Point_2>` is an output iterator, that is an
iterator to which, when dereferenced, we can assign a value. When
such an assignment to the output iterator happens somewhere inside the
convex hull function, the iterator just writes the assigned point to
standard output, because the iterator was constructed with
`std::cout`.
The call to the convex hull function takes three arguments, the input
iterator range, and the output iterator to which the result gets
written.
If you know the \stl, the Standard Template Library, the above makes
perfect sense, as this is the way the \stl decouples algorithms from
containers. If you don't know the \stl, you maybe better first
familiarize yourself with its basic ideas.
Further Reading
===============
We also recommend the standard text books by
Josuttis \cite cgal:j-csl-99 , or Austern \cite cgal:a-gps-98 for the
\stl and its notion of *concepts* and *models*.
Other resources for \cgal are the tutorials at
http://www.cgal.org/Tutorials/ and the user support page at
http://www.cgal.org/.
*/

472
Documentation/doc/Preliminaries.txt Normal file
View File

@ -0,0 +1,472 @@
/*!
\page preliminaries Preliminaries
\author CGAL Editorial Board
This chapter lists the licenses
under which the \cgal datastructures and algorithms are distributed.
The chapter further explains how to control inlining, thread safety,
code deprecation, checking of pre- and postconditions,
and how to alter the failure behavior.
\section licenseIssues License Issues
\cgal is distributed under a dual license scheme, that is under the
\sc{Gpl}/\sc{Lgpl} open source license, as well as under commercial licenses.
\cgal consists of different parts covered by different open source licenses.
In this section we explain the essence of the different licenses, as well as
the rationale why we have chosen them.
The fact that \cgal is Open Source software does not mean that users are free
to do whatever they want with the software. Using the software means to accept
the license, which has the status of a contract between the user and the owner
of the \cgal software.
\subsection licensesGPL GPL
The \sc{Gpl} is an Open Source license that, if you distribute your software
based on \sc{Gpl} ed \cgal data structures,you are obliged to distribute the
source code of your software under the \sc{Gpl}.
The exact license terms can be found at the Free Software Foundation
web site: http://www.gnu.org/copyleft/gpl.html.
\subsection licensesLGPL LGPL
The \sc{Lgpl} is an Open Source license that obliges you to distribute
modifications you make on \cgal software accessible to the users.
In contrast to the \sc{Gpl} , there is no obligation to make the source
code of software you build on top of \sc{Lgpl}ed \cgal data structures
The exact license terms can be found at the Free Software Foundation web site:
http://www.gnu.org/copyleft/lesser.html.
Rationale of the License Choice
------------------------------
We have chosen the \sc{Gpl} and the \sc{Lgpl} as they are well known
and well understood open source licenses. The former restricts
commercial use, and the latter allows to promote software as de facto standard
so that people can build new higher level data structures on top.
Therefore, the packages forming a foundation layer are distributed under
the \sc{Lgpl}, and the higher level packages under the \sc{Gpl}.
The package overview states for each package under which license
it is distributed.
\subsection licensesCommercial Commercial Licenses
Users who cannot comply to the Open Source license terms can buy individual
data structures under various commercial licenses from GeometryFactory:
http://www.geometryfactory.com/. License fees paid by commercial
customers are reinvested in R\&D performed by the \cgal project partners,
as well as in evolutive maintenance.
Marking of Special Functionality
================================
In this manual you will encounter sections marked as follows.
Advanced Features
-----------------
Some functionality is considered more advanced, for example because it is
relatively low-level, or requires special care to be properly used.
\advanced Such functionality is identified this way in the manual.
Debugging Support Features
--------------------------
Usually related to advanced features that for example may not guarantee
class invariants, some functionality is provided that helps debugging,
for example by performing invariants checks on demand.
\debug Such functionality is identified this way in the manual.
Deprecated Code
---------------
Sometimes, the \cgal project decides that a feature is deprecated. This means
that it still works in the current release, but it will be removed in the next,
or a subsequent release. This can happen when we have found a better way to do
something, and we would like to reduce the maintenance cost of \cgal at some
point in the future. There is a trade-off between maintaining backward
compatibility and implementing new features more easily.
In order to help users manage the changes to apply to their code, we attempt
to make \cgal code emit warnings when deprecated code is used. This can be
done using some compiler specific features. Those warnings can be disabled
by defining the macro `CGAL_NO_DEPRECATION_WARNINGS`. On top of this, we
also provide a macro, `CGAL_NO_DEPRECATED_CODE`, which, when defined,
disables all deprecated features. This allows users to easily test if their
code relies on deprecated features.
\deprecated Such functionality is identified this way in the manual.
Namespace CGAL
==============
All names introduced by \cgal, especially those documented in these
manuals, are in a namespace called `CGAL`, which is in global
scope. A user can either qualify names from \cgal by adding
`CGAL::`, e.g., `CGAL::Point_2< CGAL::Exact_predicates_inexact_constructions_kernel >`,
make a single name from \cgal visible in a scope via a `using`
statement, e.g., `using CGAL::Point_2;`, and then use this name
unqualified in this scope, or even make all names from namespace
`CGAL` visible in a scope with `using namespace CGAL;`. The
latter, however, is likely to give raise to name conflicts and is
therefore not recommended.
Inclusion Order of Header Files
===============================
Not all compilers fully support standard header names. \cgal provides
workarounds for these problems in `CGAL/basic.h`. Consequently, as a
golden rule, you should always include `CGAL/basic.h` first in your
programs (or `CGAL/Cartesian.h`, or `CGAL/Homogeneous.h`, since they
include `CGAL/basic.h` first).
Thread Safety
=============
\cgal is progressively being made thread-safe. The guidelines which are followed
are:
- it should be possible to use different objects in different threads at the same time (of the same type or not),
- it is not safe to access the same object from different threads at the same time, unless otherwise specified in the class documentation.
If the macro `CGAL_HAS_THREADS` is not defined, then \cgal assumes it can use
any thread-unsafe code (such as static variables). By default, this macro is not
defined, unless `BOOST_HAS_THREADS` or `_OPENMP` is defined. It is possible
to force its definition on the command line, and it is possible to prevent its default
definition by setting `CGAL_HAS_NO_THREADS` from the command line.
C++0x Support
=============
\cgal is based on the \CC standard released in 1998 (and later refined in 2003).
A new major version of this standard is being prepared, and is refered to as C++0x.
Some compilers and standard library implementations already provide some of the
functionality of this new standard, as a preview. For example, \gcc provides
a command-line switch `-std=c++0x` which enables some of those features.
\cgal attempts to support this mode progressively, and already makes use of
some of these features if they are available, although no extensive support has
been implemented yet.
Functor Return Types
====================
\cgal functors support the
<a href="http://www.boost.org/doc/libs/release/libs/utility/utility.htm#result_of">result_of</a>
protocol. If a functor `F` has the same return type across all
overloads of `operator()`, the nested type
`F::result_type` is defined to be that type. Otherwise the
return type of calling the functor with an argument of type
`Arg` can be accessed through
`boost::result_of<F(Arg)>::type`.
\section secchecks Checks
Much of the \cgal code contains checks.
For example, all checks used in the kernel code are prefixed by
`CGAL_KERNEL`.
Other packages have their own prefixes, as documented in the corresponding
chapters.
Some are there to check if the kernel behaves correctly, others are there to
check if the user calls kernel routines in an acceptable manner.
There are five types of checks.
The first three are errors and lead to a halt of the program if they fail.
The fourth only leads to a warning, and the last one is compile-time only.
<DL>
<DT>Preconditions</DT>
<DD>
check if the caller of a routine has called it in a proper fashion.
If such a check fails it is the responsibility of the caller (usually the user of the library).
</DD>
<DT>Postconditions</DT>
<DD>
check if a routine does what it promises to do.
If such a check fails it is the fault of this routine, so of the library.
</DD>
<DT>Assertions</DT>
<DD>
are other checks that do not fit in the above two
categories.
</DD>
<DT>Warnings</DT>
<DD>
are checks for which it is not so severe if they fail.
</DD>
<DT>Static assertions</DT>
<DD>
are compile-time assertions, used e.g. to verify
the values of compile-time constants or compare types for (in)equality.
</DD>
</DL>
By default, all of these checks are performed.
It is however possible to turn them off through the use of compile time
switches.
For example, for the checks in the kernel code, these switches are the
following:
`CGAL_KERNEL_NO_PRECONDITIONS`,
`CGAL_KERNEL_NO_POSTCONDITIONS`,
`CGAL_KERNEL_NO_ASSERTIONS` and
`CGAL_KERNEL_NO_WARNINGS`.
So, in order to compile the file `foo.cpp` with the postcondition checks
off, you can do:
`CC -DCGAL_KERNEL_NO_POSTCONDITIONS foo.cpp`
This is also preferably done by modifying your makefile by adding
`-DCGAL_KERNEL_NO_POSTCONDITIONS` to the `CXXFLAGS` variable.
The name `KERNEL` in the macro name can be replaced by a package
specific name in order to control assertions done in a given package.
This name is given in the documentation of the corresponding package,
in case it exists.
Note that global macros can also be used to control the behavior over the
whole \cgal library:
- `CGAL_NO_PRECONDITIONS`,
- `CGAL_NO_POSTCONDITIONS`,
- `CGAL_NO_ASSERTIONS`,
- `CGAL_NO_WARNINGS` and
- `CGAL_NDEBUG`.
Setting the macro `CGAL_NDEBUG` disables all checks.
Note that the standard flag `NDEBUG` sets `CGAL_NDEBUG`, but it also
affects the standard `assert` macro.
This way, adding `-DCGAL_NDEBUG` to your compilation flags removes
absolutely all checks. This is the default recommended setup for performing
timing benchmarks for example.
Not all checks are on by default.
The first four types of checks can be marked as expensive or exactness checks
(or both).
These checks need to be turned on explicitly by supplying one or both of
the compile time switches `CGAL_KERNEL_CHECK_EXPENSIVE` and
`CGAL_KERNEL_CHECK_EXACTNESS`.
Expensive checks are, as the word says, checks that take a considerable
time to compute.
Considerable is an imprecise phrase.
Checks that add less than 10 percent to the execution time of the routine
they are in are not expensive.
Checks that can double the execution time are.
Somewhere in between lies the border line.
Checks that increase the asymptotic running time of an algorithm are always
considered expensive.
Exactness checks are checks that rely on exact arithmetic.
For example, if the intersection of two lines is computed, the postcondition
of this routine may state that the intersection point lies on both lines.
However, if the computation is done with doubles as number type, this may not
be the case, due to round off errors.
So, exactness checks should only be turned on if the computation is done
with some exact number type.
By definition, static assertions are both inexpensive and unaffected by precision
management. Thus, the categories do not apply for static assertions.
Altering the Failure Behavior
----------------------------
As stated above, if a postcondition, precondition or assertion is
violated, an exception is thrown, and if nothing is done to catch it,
the program will abort.
This behavior can be changed by means of the following function.
`CGAL/assertions_behaviour.h`
`Failure_behaviour set_error_behaviour(Failure_behaviour eb);`
The parameter should have one of the following values.
`enum Failure_behaviour { ABORT, EXIT, EXIT_WITH_SUCCESS, CONTINUE, THROW_EXCEPTION };`
The `THROW_EXCEPTION` value is the default, which throws an exception.
If the `EXIT` value is set, the program will stop and return a value
indicating failure, but not dump the core.
The `CONTINUE` value tells the checks to go on after diagnosing the error.
Note that since \cgal 3.4, `CONTINUE` has the same effect as
`THROW_EXCEPTION` for errors (but it keeps its meaning for warnings), it is
not possible anymore to let assertion failures simply continue (except by
totally disabling them).
\beginadvanced
If the `EXIT_WITH_SUCCESS` value is set, the program will stop and
return a value corresponding to successful execution and not dump the core.
\endadvanced
The value that is returned by `set_error_behaviour` is the value that was in use before.
For warnings there is a separate routine, which works in the same way.
The only difference is that for warnings the default value is
`CONTINUE`.
`Failure_behaviour set_warning_behaviour(Failure_behaviour eb);`
Control at a Finer Granularity
------------------------------
The compile time flags as described up to now all operate on the whole
library.
Sometimes you may want to have a finer control.
\cgal offers the possibility to turn checks on and off with a bit finer
granularity, namely the module in which the routines are defined.
The name of the module is to be appended directly after the \cgal prefix.
So, the flag `CGAL_KERNEL_NO_ASSERTIONS` switches off assertions in
the kernel only, the flag `CGAL_CH_CHECK_EXPENSIVE` turns on
expensive checks in the convex hull module.
The name of a particular module is documented with that module.
\beginadvanced
Customizing how Errors are Reported
-----------------------------------
Normally, error messages are written to the standard error output.
It is possible to do something different with them.
To that end you can register your own handler.
This function should be declared as follows.
`void my_failure_function( const char *type, const char *expression,
const char *file, int line, const char *explanation);`
Your failure function will be called with the following parameters.
`type` is a string that contains one of the words precondition,
postcondition, assertion or warning.
The parameter `expression` contains the expression that was violated.
`file` and `line` contain the place where the check was made.
The `explanation` parameter contains an explanation of what was
checked.
It can be `NULL`, in which case the `expression` is thought
to be descriptive enough.
There are several things that you can do with your own handler.
You can display a diagnostic message in a different way, for instance in
a pop up window or to a log file (or a combination).
You can also implement a different policy on what to do after an error.
For instance, you can throw an exception or ask the user in a dialog
whether to abort or to continue.
If you do this, it is best to set the error behavior to
`CONTINUE`, so that it does not interfere with your policy.
You can register two handlers, one for warnings and one for errors.
Of course, you can use the same function for both if you want.
When you set a handler, the previous handler is returned, so you can restore
it if you want.
`CGAL/assertions.h`
- `Failure_function set_error_handler(Failure_function handler);`
- `Failure_function set_warning_handler(Failure_function handler);`
### Example ###
\code{.cpp}
#include <CGAL/assertions.h>
void my_failure_handler(
const char *type,
const char *expr,
const char* file,
int line,
const char* msg)
{
/* report the error in some way. */
}
void foo()
{
CGAL::Failure_function prev;
prev = CGAL::set_error_handler(my_failure_handler);
/* call some routines. */
CGAL::set_error_handler(prev);
}
\endcode
\endadvanced
\section seccgal_version Identifying the Version of CGAL
`CGAL/config.h`
Every release of \cgal defines the following preprocessor macros:
\yada
<DL>
<DT>`CGAL_VERSION`</DT>
<DD> a textual description of the current release (e.g., or 3.3 or 3.2.1 or 3.2.1-I-15)</DD>
<DT>`CGAL_VERSION_STR`</DT>
<DD>same as `CGAL_VERSION` but as a string constant token</DD>
<DT>`CGAL_VERSION_NR`</DT>
<DD>a numerical description of the current release such that more recent
releases have higher number.
More precisely, it is defined as `1MMmmbiiii`, where `MM` is
the major release number (e.g. 03), `mm` is the minor release
number (e.g. 02), `b` is the bug-fix release number (e.g. 0),
and `iiii` is the internal release number (e.g. 0001). For
public releases, the latter is defined as 1000. Examples: for the
public release 3.2.4 this number is 1030241000; for internal release
3.2-I-1, it is 1030200001. Note that this scheme was modified around
3.2-I-30.
</DD>
<DT>`CGAL_VERSION_NUMBER(M,m,b)`</DT>
<DD>
a function macro computing the version number macro from the
M.m.b release version. Note that the internal release number is
dropped here. Example: `CGAL_VERSION_NUMBER(3,2,4)` is equal to
1030241000.
</DD>
<DL>
\beginadvanced
Compile-time Flags to Control Inlining
======================================
Making functions inlined can, at times, improve the efficiency of your code.
However this is not always the case and it can differ for a single function
depending on the application in which it is used. Thus \cgal defines a set
of compile-time macros that can be used to control whether certain functions
are designated as inlined functions or not. The following table lists the
macros and their default values, which are set in one of the \cgal include
files.
| macro name | default |
| :--------- | :------ |
| `CGAL_KERNEL_INLINE` | inline |
| `CGAL_KERNEL_MEDIUM_INLINE` | |
| `CGAL_KERNEL_LARGE_INLINE` | |
| `CGAL_MEDIUM_INLINE` | inline |
| `CGAL_LARGE_INLINE` | |
| `CGAL_HUGE_INLINE` | |
If you wish to change the value of one or more of these macros,
you can simply give it a new value when compiling. For example, to make
functions that use the macro `CGAL_KERNEL_MEDIUM_INLINE` inline functions,
you should set the value of this macro to `inline` instead of the
default blank.
Note that setting inline manually is very fragile, especially in a template
context. It is usually better to let the compiler select by himself which
functions should be inlined or not.
\endadvanced
*/

2342
Documentation/doc/cgal_manual.bib Normal file
View File

File diff suppressed because it is too large Load Diff

20
Documentation/doc/footer.html Normal file
View File

@ -0,0 +1,20 @@
<!-- start footer part -->
<!--BEGIN GENERATE_TREEVIEW-->
<div id="nav-path" class="navpath"><!-- id is needed for treeview function! -->
<ul>
$navpath
<li class="footer">$generatedby
<a href="http://www.doxygen.org/index.html">
<img class="footer" src="$relpath$doxygen.png" alt="doxygen"/></a> $doxygenversion </li>
</ul>
</div>
<!--END GENERATE_TREEVIEW-->
<!--BEGIN !GENERATE_TREEVIEW-->
<hr class="footer"/><address class="footer"><small>
$generatedby &#160;<a href="http://www.doxygen.org/index.html">
<img class="footer" src="$relpath$doxygen.png" alt="doxygen"/>
</a> $doxygenversion
</small></address>
<!--END !GENERATE_TREEVIEW-->
</body>
</html>

54
Documentation/doc/header.html Normal file
View File

@ -0,0 +1,54 @@
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=9"/>
<!--BEGIN PROJECT_NAME--><title>$projectname: $title</title><!--END PROJECT_NAME-->
<!--BEGIN !PROJECT_NAME--><title>$title</title><!--END !PROJECT_NAME-->
<link href="$relpath$tabs.css" rel="stylesheet" type="text/css"/>
<link href="" rel="canonical" />
<script type="text/javascript" src="$relpath$jquery.js"></script>
<script type="text/javascript" src="$relpath$dynsections.js"></script>
$treeview
$search
$mathjax
<link href="cgal.ico" rel="shortcut icon" />
<link href="stylesheet.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<!--BEGIN TITLEAREA-->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
<tbody>
<tr style="height: 56px;">
<!--BEGIN PROJECT_LOGO-->
<td id="projectlogo"><img alt="Logo" src="$relpath$$projectlogo"/></td>
<!--END PROJECT_LOGO-->
<!--BEGIN PROJECT_NAME-->
<td style="padding-left: 0.5em;">
<div id="projectname">$projectname
<!--BEGIN PROJECT_NUMBER-->&#160;<span id="projectnumber">$projectnumber</span><!--END PROJECT_NUMBER-->
</div>
<!--BEGIN PROJECT_BRIEF--><div id="projectbrief">$projectbrief</div><!--END PROJECT_BRIEF-->
</td>
<!--END PROJECT_NAME-->
<!--BEGIN !PROJECT_NAME-->
<!--BEGIN PROJECT_BRIEF-->
<td style="padding-left: 0.5em;">
<div id="projectbrief">$projectbrief</div>
</td>
<!--END PROJECT_BRIEF-->
<!--END !PROJECT_NAME-->
<!--BEGIN DISABLE_INDEX-->
<!--BEGIN SEARCHENGINE-->
<td>$searchbox</td>
<!--END SEARCHENGINE-->
<!--END DISABLE_INDEX-->
</tr>
</tbody>
</table>
</div>
<!--END TITLEAREA-->
<!-- end header part -->

61
Documentation/doc/main.txt Normal file
View File

@ -0,0 +1,61 @@
/*!
\mainpage CGAL
The goal of the CGAL Open Source Project is to provide easy access to
efficient and reliable geometric algorithms in the form of a C++
library. CGAL is used in various areas needing geometric computation,
such as: computer graphics, scientific visualization, computer aided
design and modeling, geographic information systems, molecular
biology, medical imaging, robotics and motion planning, mesh
generation, numerical methods... More on the projects using CGAL web
page.
The Computational Geometry Algorithms Library (CGAL), offers data
structures and algorithms like triangulations (2D constrained
triangulations and Delaunay triangulations in 2D and 3D, periodic
triangulations in 3D), Voronoi diagrams (for 2D and 3D points, 2D
additively weighted Voronoi diagrams, and segment Voronoi diagrams),
polygons (Boolean operations, offsets, straight skeleton), polyhedra
(Boolean operations), arrangements of curves and their applications
(2D and 3D envelopes, Minkowski sums), mesh generation (2D Delaunay
mesh generation and 3D surface and volume mesh generation, skin
surfaces), geometry processing (surface mesh simplification,
subdivision and parameterization, as well as estimation of local
differential properties, and approximation of ridges and umbilics),
alpha shapes, convex hull algorithms (in 2D, 3D and dD), search
structures (kd trees for nearest neighbor search, and range and
segment trees), interpolation (natural neighbor interpolation and
placement of streamlines), shape analysis, fitting, and distances
(smallest enclosing sphere of points or spheres, smallest enclosing
ellipsoid of points, principal component analysis), and kinetic data
structures.
All these data structures and algorithms operate on geometric objects
like points and segments, and perform geometric tests on them. These
objects and predicates are regrouped in CGAL Kernels.
Finally, the Support Library offers geometric object generators and
spatial sorting functions, as well as a matrix search framework and a
solver for linear and quadratic programs. It further offers interfaces
to third party software such as the GUI libraries Qt, Geomview, and
the Boost Graph Library. License
CGAL is distributed under a dual-license scheme. CGAL can be used
together with Open Source software free of charge. Using CGAL in other
contexts can be done by obtaining a commercial license from
GeometryFactory. For more details see the License page.
\page packages CGAL
\tableofcontents
\section general_introduction I General Introduction
<ol>
<li>\ref introduction</li>
<li>\ref preliminaries</li>
<li>\ref installation</li>
</ol>
*/

1103
Documentation/doc/stylesheet.css Normal file
View File

File diff suppressed because it is too large Load Diff