+
+where the second line creates a `CMakeLists.txt` file (check
+its options in Section \ref seccreate_cgal_CMakeLists for various details).
+
+In a less ideal world, you probably have to install CMake, a makefile
+generator, and third party libraries. That is what this manual is about.
+
+\section secprerequisites Prerequisites
+
+Installing \cgal requires a few components to be installed ahead: a
+supported compiler (see Section \ref seccompilers, CMake, \sc{Boost}, and at least \sc{Gmp}, and \sc{Mpfr}; see
+Section \ref secessential3rdpartysoftware for more details on
+essential third party software.
+
+\section secshippedcgal OS-shipped %CGAL
+
+Some operating systems with package managers offer \cgal and its
+essential third party software through the manager,
+for instance, Mac OS X, or some Linux distribution (e.g. Debian).
+
+\subsection sseccgalmacosxe %CGAL on MAC OS X
+
+For instance, use macports in the following way:
+
+
+sudo port install cgal
+
+
+or if Qt4 demos are desired
+
+
+sudo port install cgal +qt4 +universal +demos
+
+
+The setup is similar for homebrew.
+
+\subsection sseccgaldebian %CGAL on Linux
+
+For instance in debian/Ubuntu, use apt-get in the following way:
+
+
+sudo apt-get install libcgal-dev
+
+
+To get the demos use
+
+
+sudo apt-get install libcgal-demo
+
+
+Check the \cgal-FAQ for source repository of newest releases.
+
+On other distributions, please consult your package manager documentation.
+
+\section secgettingcgal Downloading %CGAL
+
+You can obtain the \cgal library from
+http://www.cgal.org/download.html
+and install it yourself.
+
+After you have downloaded the file `CGAL-x.y.tar.gz` containing the
+\cgal sources, you have to unpack it. Under a Unix-like shell, use the
+command:
+
+
+tar xzf `CGAL-x.y`.tar.gz
+
+
+When you are on Windows you may download and run `CGAL-x.y-Setup.exe`. It
+is a self extracting executable that installs the \cgal source, and that allows
+you to select and download some precompiled third party libraries.
+
+In both cases the directory `CGAL-x.y` will be created. This directory
+contains the following subdirectories:
+
+
+
+
+
+directory
+
+contents
+
+
+`auxiliary`
+
+precompiled \sc{Gmp}, \sc{Mpfr} and \sc{Taucs} for Windows
+
+
+`cmake/modules`
+
+modules for finding and using libraries
+
+
+`config`
+
+configuration files for install script
+
+
+`demo`
+
+demo programs (most of them need \sc{Qt}, geomview or other third-party products)
+
+
+`doc_html`
+
+documentation (HTML)
+
+
+`examples`
+
+example programs
+
+
+`include`
+
+header files
+
+
+`scripts`
+
+some useful scripts (e.g. for creating CMakeLists.txt files)
+
+
+`src`
+
+source files
+
+
+
+
+The directories `include/CGAL/CORE` and `src/CGALCore` contain a
+distribution of the \sc{Core} library\footnote{`http://www.cs.nyu.edu/exact/`} version 1.7 for
+dealing with algebraic numbers. \sc{Core} is not part of \cgal and has its
+own license.
+
+The directory `include/CGAL/OpenNL` contains a distribution of the
+Open Numerical Library which provides solvers for sparse linear systems,
+especially designed for the Computer Graphics community. \sc{OpenNL} is not part
+of \cgal and has its own license.
+
+The only documentation shipped with \cgal sources is the present
+installation manual. The \cgal manual must be downloaded separately from
+`http://www.cgal.org/download.html`.
+
+\section seccompilers Supported Compilers
+
+In order to build the \cgal libraries, you need a \cpp compiler.
+\cgal x.y is supported for the following compilers/operating systems:
+
+
+\sc{MS} Visual `C++` 9.0, 10.0 (\sc{Visual Studio 2008 and 2010})3
+
+
+\sc{MS} Windows 95/98/2000/XP/NT4/Vista/7
+
+
+
+
+\section secconfigwithcmake Configuring %CGAL with CMake
+
+In order to configure, build, and install the \cgal libraries, examples and
+demos, you need CMake, a cross-platform "makefile generator".
+If CMake is not installed already you can obtain it from `http://www.cmake.org/`.
+CMake version 2.6.2 or higher is required. On Windows, CMake
+version 2.8.6 or higher is required, for a proper support of DLL's
+generation.
+This manual explains only those features of
+CMake which are needed in order to build \cgal. Please refer to the
+CMake documentation at `http://www.cmake.org/` for further details.
+
+Before building \cgal you have to choose the compiler/linker,
+set compiler and linker flags, specify which
+third-party libraries you want to use and where they can be found, and
+which \cgal libraries you want to build. Gathering
+all this information is called configuration.
+The end of the process is marked by the generation of a makefile or a
+Visual \cpp solution and project file that you can use to build \cgal.
+
+## Configuring %CGAL with the CMake Gui ##
+
+The simplest way to start the configuration is to run the graphical
+user interface of CMake. We recommend to use `cmake-gui`. It
+is available on many platforms as of CMake version 2.6. You must pass as
+argument the root directory of \cgal. For example:
+
+
+cd `CGAL-x.y`
+cmake-gui . # Notice the dot to indicate the current directory.
+
+
+After `cmake-gui` opens, press 'Configure'.
+A dialog will pop up and you will have to choose what shall gets generated.
+After you have made your choice and pressed 'Finish', you will see
+the output of configuration tests in the lower portion of the application.
+When these tests are done, you will see many
+red entries in the upper portion of the application. Just ignore them and press 'Configure'.
+By now CMake should have found many libraries and have initialized variables.
+If you still find red entries, you have to provide the necessary information.
+This typically happens if you have installed software at non-standard locations.
+Providing information and pressing 'Configure' goes on until
+all entries are grayed. You are now ready to press 'Generate'. Once this is
+done, you can quit `cmake-gui`.
+
+## Configuring %CGAL with the cmake command-line tool ##
+
+Alternatively, you can run the command-line tool called
+`cmake`. You pass as argument the root directory of
+\cgal. For example:
+
+
+cd `CGAL-x.y`
+cmake . # Notice the dot to indicate the current directory.
+
+
+The very first thing CMake does is to detect the compiler to use. This
+detection is performed by a special CMake module called a
+generator.
+A CMake generator understands the build requirements for a
+particular compiler/linker and generates the necessary files for that. For
+example, the UNIX Makefiles generator understands the GNU chain
+of tools (\gcc, ld etc.) and produces makefiles, which can be used to build a
+target by a simple call to `make`. Likewise, the Visual Studio
+2010 generator produces solution and project files and can be manually
+launched in the VS IDE to build the target.
+
+Each platform has a default generator, so you only need to select one when
+the default is not what you want. For example, under Windows, it is
+possible to generate NMakefiles instead of Visual Studio project
+files in order to build the library with `nmake`. Running
+`cmake` with no parameters in a command-line prints the list of
+available generators supported by your platform and CMake version. If the
+generator you need is not listed there, you can try a newer
+CMake version, as generators are hardcoded into CMake, and additional
+generators are added with each release.
+
+Since the choice of the generator determines the type of build files to generate, in some cases
+you choose a particular generator as a mean to choose a specific compiler (because they use different
+build files). For example, the following generates solution files for
+use in Visual \cpp 11.0 on a 64bit machine:
+
+
+cd `CGAL-x.y`
+cmake -G"Visual Studio 11 Win64" .
+
+
+In other cases, however, the generator doesn't directly identify a
+specific compiler but a chain of tools.
+For example, the `UNIX Makefiles` generator produces `makefiles` that call some auto-detected
+command-line compiler, like \gcc. If you need the makefiles to use a different compiler, you need to
+specify the desired compiler in the call to CMake, as in this example:
+
+
+
+CMake maintains configuration parameters in so-called cmake variables, like the `CMAKE_CXX_COMPILER`
+in the example above. These variables are not environment variables but CMake variables. Some of the CMake
+variables represent user choices, such as `WITH_examples` or `CMAKE_BUILD_TYPE=Release`, while others
+indicate the details of a third-party library, such as `Boost_INCLUDE_DIR` or the compiler flags to use,
+such as `CMAKE_CXX_FLAGS`.
+
+The command line tool `cmake` accepts CMake variables as arguments of the form `-D:=`, as
+in the example above, but this is only useful if you already know which variables need to be explicitly defined.
+
+\advanced CMake keeps the variables that a user can manipulate in a
+so-called CMake cache, a simple text file named
+`CMakeCache.txt`, whose entries are of the form
+`VARIABLE:TYPE=VALUE`. Advanced users can manually edit this file,
+instead of going through the interactive configuration session.
+
+
+The configuration process not only determines the location of the required dependencies, it also dynamically generates a
+`compiler_config.h` file, which encodes the properties of your system and a special file named
+`CGALConfig.cmake`, which is used to build programs using \cgal. The
+purpose of this file is explained below.
+
+\section seclibraries %CGAL Libraries
+
+\cgal is split into five libraries. During configuration, you can select the libraries that
+you would like to build by setting a CMake variable of the form WITH_. By default all
+are switched `ON`. All activated libraries are build after
+configuration; see \ref secbuilding
+
+We next list the libraries and essential 3rd party software
+(see \ref secessential3rdpartysoftware) for each library:
+
+
+`QGraphicsView` support for \sc{Qt}4-based demos
+
+\sc{Qt}4 and \sc{OpenGL}
+
+
+
+
+## Debug vs. Release ##
+
+The CMake variable `CMAKE_BUILD_TYPE` indicates how to build
+the libraries. It accepts the values `Release` or
+`Debug`. The default is `Release` and should be kept, unless you want to debug
+your program.
+
+This is not an issue for solution/project files, as there the user selects the build type from within the IDE.
+
+## Static vs. Shared Libraries ##
+
+Shared libraries, also called dynamic-link libraries, are built by default
+(`.dll` on Windows, `.so` on Linux, `.dylib` on MacOS). You
+can choose to produce static libraries instead by setting the CMake
+variable `BUILD_SHARED_LIBS` to `FALSE`. If you use
+`cmake-gui`, a tick box for that variable is available to set it.
+
+These setting affect the variants of third-party libraries (see next
+section) selected whenever the choice is available.
+
+\section secessential3rdpartysoftware Essential Third Party Libraries
+
+The focus of \cgal is on geometry, and we rely on other
+highly specialized libraries and software for non-geometric issues,
+for instance, for numeric solvers, or visualization. We first list software
+that is essential to build (all) libraries of \cgal, that is,
+this software must be found during the configuration of \cgal for an
+actived library of \cgal (i.e. WITH_=ON);
+see \ref sec3partysoftwareconfig to specify the location of 3rd
+party software.
+
+The libraries \stl (shipped with any compiler) and \sc{Boost} are essential to all components (i.e. libCGAL,
+libCGAL_Core, libCGAL_ImageIO, libCGAL_Qt3 and libCGAL_Qt4).
+
+\subsection thirdpartystl Standard Template Library (STL)
+
+\cgal heavily uses the \stl, and in particular adopted
+many of its design ideas. You can find online
+documentation for the \stl at various web sites, for instance,
+`http://www.sgi.com/tech/stl/`, `http://www.cplusplus.com/reference/`,
+or `http://msdn.microsoft.com/en-us/library/1fe2x6kt(VS.100).aspx`.
+
+The \stl comes with the compiler, so there is nothing to install.
+
+\subsection thirdpartyBoost Boost
+
+The \sc{Boost} libraries are a set of portable C++ source libraries. Most of
+\sc{Boost} libraries are header-only, but a few of them need to be compiled or
+installed as binaries.
+
+\cgal requires the \sc{Boost} libraries. In particular the header files
+and the threading library (`Boost.Thread` and
+`Boost.System` binaries). Version 1.39 (or higher) are needed.
+
+On Windows, as auto-linking is used, you also need the binaries of
+`Boost.Serialization` and `Boost.DateTime`, but the
+dependency is artificial and used only at link-time: the CGAL libraries do
+not depend on the DLL's of those two libraries.
+
+In \cgal some demos and examples depend on `Boost.Program_options`.
+
+In case the \sc{Boost} libraries are not installed on your system already, you
+can obtain them from `http://www.boost.org/`. For Windows you can download an
+installer from `http://www.boostpro.com/download/`.
+Since `Boost.Thread` is required, make sure to either install the precompiled
+libraries for your compiler or build `libboost-thread` and `libboost-system`.
+
+As on Windows there is no canonical directory for where to find
+\sc{Boost}, we recommend that you define the environment variable
+`BOOST_ROOT` and set it to where you have installed \sc{Boost}, e.g.,
+`C:\boost\boost_1_41_0`.
+
+\subsection thirdpartyMPFR Gmp and Mpfr
+
+The components libCGAL, libCGAL_Core, libCGAL_Qt3 and libCGAL_Qt4 require
+\sc{Gmp} and \sc{Mpfr} which are libraries for multi precision integers and rational numbers,
+and for multi precision floating point numbers.
+
+\cgal combines floating point arithmetic with exact arithmetic,
+in order to be efficient and reliable. \cgal has a built-in
+number type for that, but \sc{Gmp} and \sc{Mpfr} provide a faster
+solution, and we recommend to use them.
+
+Having \sc{Gmp} version 4.2 or higher and \sc{Mpfr} version 2.2.1 or higher
+installed is recommended. These libraries can be obtained from
+`http://gmplib.org/` and `http://www.mpfr.org/`, respectively.
+
+As Visual \cpp is not properly
+supported by the \sc{Gmp} and \sc{Mpfr} projects, we provide precompiled versions
+of \sc{Gmp} and \sc{Mpfr}, which can be downloaded with the installer
+`CGAL-x.y-Setup.exe`.
+
+\subsection thirdpartyzlib zlib
+
+\sc{zlib} is a data compression library, and is essential for the component libCGAL_ImageIO.
+
+In \cgal this library is used in the examples of the \ref PkgSurfaceMesher3 package.
+
+If it is not already on your system,
+for instance, on Windows, you can download it from `http://www.zlib.net/`.
+
+\subsection thirdpartyOpenGL OpenGL
+
+\sc{OpenGL} (Open Graphics Library) provides an API for applications that
+produce 2D and 3D computer graphics.
+
+In \cgal the library is essential for the components libCGAL_Qt3 and
+libCGAL_Qt4, as well as libCGAL_ImageIO and for various demos.
+
+Typically, \sc{OpenGL} is preinstalled on systems; if not, it can be
+downloaded from `http://www.opengl.org/`.
+
+\subsection thirdpartyQt Qt3 and Qt4
+
+Qt is a cross-platform application and UI framework.
+
+The component libCGAL_Qt3 requires \sc{Qt}3 installed on your system, while
+the component libCGAL_Qt4 requires \sc{Qt}4 installed on your system.
+In case \sc{Qt} is not yet installed on your system, you can download
+it from `http://qt-project.org/`.
+
+Older demos of \cgal use libCGAL_Qt3 and \sc{Qt}3, while newer and newly
+developed demos require libCGAL_Qt4 and \sc{Qt}4.
+
+Having \sc{Qt}4 version 4.3.0 or higher is recommended.
+
+# %CGAL Examples and Demos #
+
+\cgal is distributed with a large collection of examples and demos. By default, these are not configured along with
+the \cgal libraries, unless you set the variables `WITH_examples=ON` and/or `WITH_demos=ON`.
+
+Nevertheless, even when configured with \cgal, they are not automatically built along with the libraries.
+You must build the `examples` or `demos` targets (or IDE projects) explicitly.
+
+If you do not plan to compile any demos, you might skip some of the essential libraries (as \sc{Qt} or
+\sc{OpenGL}), as the corresponding \cgal-libraries are not linked. But for
+your own demos you might need these \cgal-libraries.
+
+\section secoptional3rdpartysoftware Optional Third Party Libraries
+
+Optional 3rd party software is only required to build examples and
+demos shipped with \cgal or to build your own project using \cgal. In order
+to simplify these builds, various libraries can be prepared to be
+used with \cgal while configuring \cgal, just in the same way as
+essential libraries are configured. Whenever building an example or a
+demo (or your own executable), these preconfigured libraries
+are available when using \cgal.
+
+\subsection thirdpartyLeda Leda
+
+\leda is a library of efficient data structures and
+algorithms. Like \sc{Core}, \leda offers a real number data type.
+
+In \cgal this library is optional, and its number types can
+be used as an alternative to \sc{Gmp}, \sc{Mpfr}, and \sc{Core}.
+
+Free and commercial editions of \leda are available from `http://www.algorithmic-solutions.com/leda/index.html`.
+
+\subsection thirdpartyMPFI Mpfi
+
+\sc{Mpfi} provide arbitrary precision interval arithmetic with intervals
+represented using \sc{Mpfr} reliable floating-point numbers.
+It is based on the \sc{Gmp} library and on the \sc{Mpfr} library.
+In the setting of \cgal it is mainly used in sync with Rs.
+The library is optional and needed in certain algebraic
+kernels.
+
+\sc{Mpfi} can be downloaded from `http://mpfi.gforge.inria.fr/`. Version 1.4 or higher is recommended.
+
+\subsection thirdpartyRS3 Rs and Rs3
+
+Rs (Real Solutions) is devoted to the study of the real
+roots of polynomial systems with a finite number of complex roots
+(including univariate polynomials).
+
+In \cgal, Rs is used by one model of the \ref PkgAlgebraicKerneld.
+
+Rs is freely distributable for non-commercial use. You can download it
+from `http://vegas.loria.fr/rs/`. The library Rs needs \sc{Mpfi}, which can be downloaded from `http://mpfi.gforge.inria.fr/`.
+Version 1.4 or higher is recommended.
+
+The successor of Rs is called Rs3. It less restrictive when it comes
+to licencing and also contains improved and more efficient interfaces.
+Mainly parts in \cgal's algebraic kernel require Rs3.
+
+\subsection thirdpartyNTL Ntl
+
+\sc{Ntl} provides data structures and algorithms for signed, arbitrary
+length integers, and for vectors, matrices, and polynomials over the
+integers and over finite fields. In \cgal \sc{Ntl} is used to speed up
+polynomial operations such as GCDs. It is recommended to install \sc{Ntl} with support from \sc{Gmp}.
+
+\sc{Ntl} can be downloaded from `http://www.shoup.net/ntl/`. Version 5.1 or higher is recommended.
+
+\subsection thirdpartyEigen Eigen
+
+\sc{Eigen} is a `C++` template library for linear algebra. \sc{Eigen} supports all
+matrix sizes, various matrix decomposition methods and sparse linear solvers.
+
+In \cgal, \sc{Eigen} provides sparse linear solvers in the \ref PkgSurfaceReconstructionFromPointSets
+and the \ref PkgSurfaceParameterization packages.
+Since \cgal version 4.0, \sc{Eigen} is recommended over \sc{Taucs} that is not longer maintained.
+
+In addition, \sc{Eigen} also provides singular value decomposition for the \ref PkgJet_fitting_3
+and the \ref PkgRidges_3 packages.
+
+The usage of \sc{Eigen} allows to remove \sc{lapack}, \sc{blas} and \sc{Taucs} from the list of third party libraries
+required by some \cgal packages. Note that the version 3.1 (or greater) of \sc{Eigen} is required.
+
+The \sc{Eigen} web site is `http://eigen.tuxfamily.org`.
+
+\subsection thirdpartylibQGLViewer libQGLViewer
+
+libQGLViewer is a 3D widget based on \sc{Qt} 4's `QGLWidget`.
+
+In \cgal some 3D demos are based on libQGLViewer.
+
+It can be downloaded from `http://www.libqglviewer.com/`.
+
+\subsection thirdpartyCoin Coin3D
+
+\sc{Coin3D} is an implementation of Open Inventor.
+
+In \cgal, \sc{Coin3D} is used in the demo
+of the \ref PkgKds package.
+
+You can download it from `http://www.coin3d.org/`.
+
+\subsection thirdpartyESBTL Estbl
+
+The \sc{Estbl} (Easy Structural Biology Template Library) is a library that allows
+the handling of \sc{Pdb} data.
+
+In \cgal the \sc{Estbl} is used in an example of the
+\ref PkgSkinSurface3 package.
+
+It can be downloaded from `http://esbtl.sourceforge.net/`.
+
+\section secbuilding Building %CGAL
+
+The results of a successful configuration are build files that control the build step.
+The nature of the build files depends on the generator used during configuration, but in all cases they
+contain several targets, one per library, and a default global target corresponding
+to all the libraries.
+
+For example, in a \sc{Unix}-like environment the default generator produces
+makefiles. You can use the `make` command-line tool for the
+succeeding build step as follows:
+
+
+
+cd `CGAL-x.y`
+
+# build all the selected libraries at once
+
+make
+
+
+
+The resulting libraries are placed in the subdirectory `lib` under ``
+(which is `CGAL-x.y` in case you run an in-source-configuration).
+
+With generators other than `UNIX Makefiles` the resulting build files
+are solution and project files which
+should be launched in an \sc{Ide}, such as Visual Studio or KDevelop3. They will contain the targets described
+above, which you can manually build as with any other solution/project within your \sc{Ide}.
+
+Alternatively, you can build it with the command line version of the
+\sc{Visual Studio Ide}:
+
+
+
+devenv CGAL.sln /Build Debug
+
+
+
+The "Debug" argument is needed because CMake creates solution files for
+all four configurations, and you need to explicitly choose one when building
+(the other choices are Release, RelWithDebInfo and MinSizeRel).
+
+\advanced The build files produced by CMake are autoconfigured. That
+is, if you change any of the dependencies, the build step
+automatically goes all the way back to the configuration step. This
+way, once the target has been configured the very first time by
+invoking cmake, you don't necessarily need to invoke `cmake`
+again. Rebuilding will call itself `cmake` and re-generate the
+build file whenever needed. Keep this in mind if you configure \cgal
+for the Visual Studio IDE since a build could then change the
+solution/project file in-place and VS will prompt you to reload it.
+
+If you have turned on the configuration of examples
+(`-DWITH_examples=ON`) and/or demos (`-DWITH_demos=ON`), there will be additional
+targets named `examples` and `demos`, plus one target for
+each example and each demo in the build files.
+None of these targets are included by default, so you need to build them explicitly
+after the \cgal libraries have been successfully built.
+The targets `examples` and `demos` include themselves all the targets
+for examples and demos respectively.
+
+
+
+# build all examples at once
+make examples
+
+# build all demos at once
+make demos
+
+# build only the Straight Skeleton demo
+make Straight_skeleton_2_demo
+
+
+
+\advanced When using `UNIX Makefiles` you can find out the
+exact name of the example or demo target of a particular package by
+typing `make help | grep `.
+
+\section secinstalling Installing %CGAL
+
+On many platforms, library pieces such as headers, docs and binaries
+are expected to be placed in specific locations. A typical example
+being `/usr/include` and `/usr/lib` on \sc{Unix}-like
+operating systems or `C:/Program Files/` on Windows. The process
+of placing or copying the library elements into its standard location
+is sometimes referred to as Installation and it is a
+postprocessing step after the build step.
+
+CMake carries out the installation by producing a build target named install.
+The following example shows a typical session from configuration to
+installation in a \sc{Unix}-like environment:
+
+
+
+If you use a generator that produces IDE files (for Visual Studio for instance) there will be an optional
+`INSTALL` project, which you will be able to "build" to execute the installation step.
+
+\advanced The files are copied into a directory tree relative to the installation directory determined by the
+CMake variable `CMAKE_INSTALL_PREFIX`. This variable defaults to `/usr/local` under \sc{Unix}-like operating systems
+and `C:\Program Files` under Windows. If you want to install to a different location, you must override that CMake
+variable explicitly at the configuration time and not when executing the install step.
+
+The file `CGALConfig.cmake` is installed by default in
+`$CMAKE_INSTALLED_PREFIX/lib/CGAL-x.y`.
+
+# Example Configuration #
+
+Below is an example output on a linux machine with g++4.4 installed, using CMake 2.8.5,
+and the following command-line call to `cmake`:
+
+
+-- The CXX compiler identification is GNU
+-- The C compiler identification is GNU
+-- Check for working CXX compiler: /usr/bin/g++-4.4
+-- Check for working CXX compiler: /usr/bin/g++-4.4 -- works
+-- Detecting CXX compiler ABI info
+-- Detecting CXX compiler ABI info - done
+-- Check for working C compiler: /usr/bin/gcc-4.4
+-- Check for working C compiler: /usr/bin/gcc-4.4 -- works
+-- Detecting C compiler ABI info
+-- Detecting C compiler ABI info - done
+== Setting paths ==
+== Build CGAL from release: CGAL-4.1 ==
+-- Packagenames: CGAL-4.1
+== Setting paths (DONE) ==
+
+== Generate version files ==
+-- CGAL_MAJOR_VERSION=4
+-- CGAL_MINOR_VERSION=1
+-- CGAL_BUGFIX_VERSION=0
+-- CGAL_SONAME_VERSION=10
+-- CGAL_SOVERSION =10.0.0
+-- CGAL_REFERENCE_CACHE_DIR=
+-- Building shared libraries
+-- Targetting Unix Makefiles
+-- Using /usr/bin/g++-4.4 compiler.
+-- USING CMake version: 2.8.5
+-- System: Linux
+-- USING GCC_VERSION = '4.4.5'
+-- Using gcc version 4 or later. Adding -frounding-math
+== Generate version files (DONE) ==
+
+== Detect external libraries ==
+-- Build type: Release
+-- USING CXXFLAGS = ' -frounding-math -O3 -DNDEBUG'
+-- USING LDFLAGS = ' '
+-- External libraries supported: GMP;GMPXX;MPFR;zlib;OpenGL;LEDA;MPFI;RS;RS3;OpenNL;TAUCS;EIGEN3;BLAS;LAPACK;QGLViewer;ESBTL;NTL
+-- Preconfiguring library: GMP ...
+-- GMP has been preconfigured:
+-- CGAL_UseGMP-file:
+-- GMP include: /usr/include/
+-- GMP libraries: /usr/lib/libgmp.so
+-- GMP definitions:
+-- USING GMP_VERSION = '4.3.2'
+-- Preconfiguring library: GMPXX ...
+-- GMPXX has been preconfigured:
+-- CGAL_UseGMPXX-file:
+-- GMPXX include: /usr/include
+-- GMPXX libraries: /usr/lib/libgmpxx.so
+-- GMPXX definitions:
+-- Preconfiguring library: MPFR ...
+-- MPFR has been preconfigured:
+-- CGAL_UseMPFR-file:
+-- MPFR include: /usr/include/
+-- MPFR libraries: /usr/lib/libmpfr.so
+-- MPFR definitions:
+-- USING MPFR_VERSION = '3.0.0'
+-- Boost version: 1.39.0
+-- Found the following Boost libraries:
+-- thread
+-- Boost include: /usr/include/boost_1_39_0/include/boost-1_39
+-- Boost libraries: /usr/lib/libboost_thread-mt.so;pthread
+-- Boost definitions:
+-- USING BOOST_VERSION = '1.39.0'
+== Detect external libraries (DONE) ==
+
+== Write compiler_config.h ==
+-- Performing Test CGAL_CFG_ARRAY_MEMBER_INITIALIZATION_BUG - Success
+-- Performing Test CGAL_CFG_DENORMALS_COMPILE_BUG - Success
+-- Performing Test CGAL_CFG_FPU_ROUNDING_MODE_UNWINDING_VC_BUG - Success
+-- Performing Test CGAL_CFG_IEEE_754_BUG - Success
+-- Performing Test CGAL_CFG_ISTREAM_INT_BUG - Success
+-- Performing Test CGAL_CFG_LONGNAME_BUG - Success
+-- Performing Test CGAL_CFG_MATCHING_BUG_5 - Success
+-- Performing Test CGAL_CFG_MATCHING_BUG_6 - Success
+-- Performing Test CGAL_CFG_NESTED_CLASS_FRIEND_DECLARATION_BUG - Success
+-- Performing Test CGAL_CFG_NO_CPP0X_ARRAY - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_AUTO - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_COPY_N - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_DECLTYPE - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_DEFAULT_TEMPLATE_ARGUMENTS_FOR_FUNCTION_TEMPLATES - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_DELEGATING_CONSTRUCTORS - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_DELETED_AND_DEFAULT_FUNCTIONS - Success
+-- Performing Test CGAL_CFG_NO_CPP0X_INITIALIZER_LISTS - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_ISFINITE - Success
+-- Performing Test CGAL_CFG_NO_CPP0X_LAMBDAS - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_LONG_LONG - Success
+-- Performing Test CGAL_CFG_NO_CPP0X_NEXT_PREV - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_RVALUE_REFERENCE - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_STATIC_ASSERT - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_TUPLE - Failed
+-- Performing Test CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES - Failed
+-- Performing Test CGAL_CFG_NO_LIMITS - Success
+-- Performing Test CGAL_CFG_NO_LOGICAL_OPERATORS_ALTERNATIVES - Success
+-- Performing Test CGAL_CFG_NO_MESSAGE_PRAGMA_BUG - Success
+-- Performing Test CGAL_CFG_NO_NEXTAFTER - Success
+-- Performing Test CGAL_CFG_NO_STATEMENT_EXPRESSIONS - Success
+-- Performing Test CGAL_CFG_NO_STL - Success
+-- Performing Test CGAL_CFG_NO_TR1_ARRAY - Success
+-- Performing Test CGAL_CFG_NO_TR1_TUPLE - Success
+-- Performing Test CGAL_CFG_NO_WARNING_CPP_DIRECTIVE_BUG - Success
+-- Performing Test CGAL_CFG_NUMERIC_LIMITS_BUG - Success
+-- Performing Test CGAL_CFG_OUTOFLINE_MEMBER_DEFINITION_BUG - Success
+-- Performing Test CGAL_CFG_TEMPLATE_IN_DEFAULT_PARAMETER_BUG - Success
+-- Performing Test CGAL_CFG_TYPENAME_BEFORE_DEFAULT_ARGUMENT_BUG - Success
+-- Performing Test CGAL_CFG_USING_BASE_MEMBER_BUG_2 - Success
+== Write compiler_config.h (DONE) ==
+
+== Generating build files ==
+-- Configure libCGAL
+-- GMP include: /usr/include/
+-- GMP definitions:
+-- GMP libraries: /usr/lib/libgmp.so
+-- Configured GMP in standard way
+-- MPFR include: /usr/include/
+-- MPFR definitions:
+-- MPFR libraries: /usr/lib/libmpfr.so
+-- Configured MPFR in standard way
+-- libCGAL is configured
+-- Sources for CGAL component library 'Core' detected
+-- Configure libCGALCore
+-- GMP include: /usr/include/
+-- GMP definitions:
+-- GMP libraries: /usr/lib/libgmp.so
+-- Configured GMP in standard way
+-- MPFR include: /usr/include/
+-- MPFR definitions:
+-- MPFR libraries: /usr/lib/libmpfr.so
+-- Configured MPFR in standard way
+-- libCGALCore is configured
+-- Sources for CGAL component library 'Qt3' detected
+-- Sources for CGAL component library 'Qt4' detected
+-- Configure libCGALQt4
+-- Looking for Q_WS_X11
+-- Looking for Q_WS_X11 - found
+-- Looking for Q_WS_WIN
+-- Looking for Q_WS_WIN - not found.
+-- Looking for Q_WS_QWS
+-- Looking for Q_WS_QWS - not found.
+-- Looking for Q_WS_MAC
+-- Looking for Q_WS_MAC - not found.
+-- Looking for XOpenDisplay in /usr/lib/libX11.so;/usr/lib/libXext.so
+-- Looking for XOpenDisplay in /usr/lib/libX11.so;/usr/lib/libXext.so - found
+-- Looking for gethostbyname
+-- Looking for gethostbyname - found
+-- Looking for connect
+-- Looking for connect - found
+-- Looking for remove
+-- Looking for remove - found
+-- Looking for shmat
+-- Looking for shmat - found
+-- Looking for IceConnectionNumber in ICE
+-- Looking for IceConnectionNumber in ICE - found
+-- Found X11: /usr/lib/libX11.so
+-- USING QT4_VERSION = '4.6.3'
+-- OpenGL include: /usr/include
+-- OpenGL libraries: /usr/lib/libGLU.so;/usr/lib/libGL.so;/usr/lib/libSM.so;/usr/lib/libICE.so;/usr/lib/libX11.so;/usr/lib/libXext.so
+-- OpenGL definitions:
+-- Qt4 include: /usr/include/qt4
+-- Qt4 libraries: /usr/lib/libQtOpenGL.so;/usr/lib/libQtGui.so;/usr/lib/libQtCore.so
+-- Qt4 definitions:
+-- moc executable: /usr/bin/moc-qt4
+-- uic executable: /usr/bin/uic-qt4
+-- GMP include: /usr/include/
+-- GMP definitions:
+-- GMP libraries: /usr/lib/libgmp.so
+-- Configured GMP in standard way
+-- MPFR include: /usr/include/
+-- MPFR definitions:
+-- MPFR libraries: /usr/lib/libmpfr.so
+-- Configured MPFR in standard way
+-- libCGALQt4 is configured
+-- Sources for CGAL component library 'ImageIO' detected
+-- Configure libCGALImageIO
+-- Found OpenGL: /usr/lib/libGL.so
+-- Found ZLIB: /usr/lib/libz.so (found version "1.2.3.4")
+-- OpenGL include: /usr/include
+-- OpenGL libraries: /usr/lib/libGLU.so;/usr/lib/libGL.so;/usr/lib/libSM.so;/usr/lib/libICE.so;/usr/lib/libX11.so;/usr/lib/libXext.so
+-- USING ZLIB_VERSION = '1.2.3.4'
+-- libCGALImageIO is configured
+-- Sources for CGAL component libraries 'CGAL;Core;ImageIO;Qt3;Qt4' detected
+== Generating build files (DONE) ==
+
+-- Configuring done
+-- Generating done
+-- Build files have been written to: /home/user/CGAL/4.1/
+
+
+
+# Multiple Variants of makefiles (out-of-source build) #
+\anchor seccmakeoutofsource
+
+While you can choose between release or debug builds, and shared or static libraries,
+it is not possible to generate different variants during a single configuration. You need to run CMake in a
+different directory for each variant you are interested in, each with its own selection of configuration parameters.
+
+CMake stores the resulting makefiles and project files, along with several temporary and auxiliary files such
+as the variables cache, in the directory where it is executed, called `CMAKE_BINARY_DIR`, but it
+takes the source files and configuration scripts from
+`CMAKE_SOURCE_DIR`.
+
+The binary and source directories do not need to be the same. Thus, you can configure multiple variants by creating a
+distinct directory for each configuration and by running CMake from there. This is known in CMake terminology
+as out-of-source configuration, as opposite to an in-source
+configuration, as showed in the previous sections.
+
+You can, for example, generate subdirectories `CGAL-x.y``/cmake/platforms/debug` and
+`CGAL-x.y``/cmake/platforms/release` for two configurations, respectively:
+
+
+
+In this ideal world, as for all shipped examples and demos of \cgal, the
+required `CMakeLists.txt` is already provided.
+
+CMake can also be used to configure and build user programs via such
+CMake-scripts. In this less ideal world, one has to provide the
+`CMakeLists.txt` script either manually, or with the help of a
+shell-script that is introduced below.
+
+For a user program `executable.cpp`, the ideal world looks like this:
+
+
+
+In both examples we specify the `CGAL_DIR`:
+During configuration of the \cgal libraries a file named `CGALConfig.cmake` is generated in \cgal's root directory (in contrast
+to \cgal's source directory that has been used for installation). This file
+contains the definitions of several CMake variable that summarize the
+configuration of \cgal. In order to configure a program, you need
+to indicate the location of that config file in the CMake variable
+`CGAL_DIR` (as indicated in the example above).
+`CGAL_DIR` can also be an environment variable. Setting
+`CGAL_DIR` makes particular sense if having multiple
+out-of-source builds of \cgal as in Section \ref seccmakeoutofsource.
+
+If you have installed CGAL, `CGAL_DIR` must afterwards be set to
+`$CMAKE_INSTALLED_PREFIX/lib/CGAL`. Note that \cgal is
+recommended to be installed in release mode when using it to build programs.
+
+## Creating a cmake script for a program using %CGAL ##
+
+For compiling a non-shipped program, it is
+recommended, to also rely on a CMake-supported configuration using a
+`CMakeLists.txt` used for configuration.
+
+Use the following Bourne-shell script for programs that are relatively
+simple to configure:
+
+\subsection seccreate_cgal_CMakeLists cgal_create_CMakeLists
+
+The Bourne-shell script `cgal_create_CMakeLists.txt` resides in the
+`CGAL-x.y/scripts` directory. It can be used to create
+`CMakeLists.txt` files for compiling \cgal applications. Executing
+`cgal_create_CMakeLists.txt` in an application directory creates a
+`CMakeLists.txt` containing rules to build the contained
+application(s). Three command line options determine details of the
+configuration.
+
+
+
`-s source`
If this parameter is given the script will
+create a single executable for 'source' linked with
+compilations of all other source files (`*.cpp`). This
+behaviour is usually needed for (graphical) demos.
+
+If the parameter is not given, the script creates one executable for each given
+source file.
+
`-c com1:com2:...`
Lists components ("com1",
+"com2") of \cgal to which the executable(s) should be linked. Valid components are \cgal's
+libraries (i.e. "Core", "ImageIO", "Qt3" and "Qt4"; note
+that it only make sense to either pick "Qt3" or "Qt4") and all
+preconfigured 3rd party software, such as "MPFI", "RS3",
+or "LAPACK"). An example is `-c Core:GMP:RS3:MPFI`
+
+
`-b boost1:boost2:...`
Lists components ("boost1",
+"boost2") of \sc{Boost} to which the executable(s) should be
+linked. Valid options are, for instance, "filesystem" or "program_options".
+
+
+
+This options should suffice to create `CMakeLists.txt` script
+for most directories containing programs. However, in some special
+cases, it might still be required to create the script manually, for
+instance, if some source files/executables need a different linking than
+other source files.
+
+\subsection seccreate_cgal_cmake_script cgal_create_cmake_script
+
+\deprecated For backward-compatibility we still provide the
+Bourne-shell script `cgal_create_cmake_script` that is
+contained in the `CGAL-x.y/scripts` directory. It can be used
+to create `CMakeLists.txt` files for compiling \cgal
+applications. Executing `cgal_create_cmake_script` in an
+application directory creates a `CMakeLists.txt` containing
+rules for every `*.cpp` file there. The script is deprecated,
+as it only works for applications with a single course file that only
+need libCGAL and libCGAL_Core.
+
+Such a shell-script simply creates a CMake script. Processing it
+with CMake, searches for \cgal using `find_package`. If found,
+the variable `CGAL_USE_FILE` is set to a compilation environment CMake file. Including
+this file within a CMake script sets up include paths and libraries to
+link with \cgal and essential third party libraries. Beyond,
+`find_package` can demand for `COMPONENTS` of \cgal,
+that is, all \cgal libraries libCGAL_Core (``Core''),
+libCGAL_ImageIO (``ImageIO'') , libCGAL_Qt3 (``Qt3'') and libCGAL_Qt4
+(``Qt4'') or optional 3rd party software such as ``MPFI'', ``RS3'' or
+``LAPACK''. A user is free to create the `CMakeLists.txt`
+without calling the script (manual creation).
+
+## Custom flags in the programs using %CGAL ##
+
+Normally, programs linked with \cgal must be compiled with the same flags
+used by the compilation of \cgal libraries. For this reason, the very first time
+a program is configured, all the flags given by the CMake variables `CMAKE_*_FLAGS`
+are locked in the sense that the values recorded in `CGALConfig.cmake`
+are used to override any values given by CMake itself or yourself.
+
+This does not apply to the additional flags that can be given via `CGAL_*_FLAGS`.
+
+Such inherited values are then recorded in the current CMake cache for the program.
+The flags are then unlocked in the sense that at any subsequent configuration you can
+provide your own flags and this time they will not be overridden.
+
+When using the interactive `cmake-gui` the first press on `Configure` unlocks
+the flags, so that you can edit them as needed.
+
+\advanced The locking of flags is controlled by the variable
+`CGAL_DONT_OVERRIDE_CMAKE_FLAGS` which starts out FALSE and is
+toggled right after the flags have been loaded from
+`CGALConfig.cmake`.
+
+\advanced If you use the command line tool you can specify flags directly by setting the
+controlling variable right up front:
+
+\code{.sh}
+cd CGAL-x.y
+cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_FLAGS=-g .
+cd CGAL-x.y/examples/Straight_skeleton_2
+cmake -DCGAL_DIR=CGAL-x.y -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS=-O2 -DCGAL_DONT_OVERRIDE_CMAKE_FLAGS=TRUE .
+\endcode
+
+# Summary of %CGAL's Configuration Variables #
+
+Most configuration variables are not environment variables but
+CMake variables. They are given in the command line to CMake
+via the `-D` option, or passed from the interactive interface
+of `cmake-gui`. Unless indicated differently, all the variables
+summarized below are CMake variables.
+
+## Component selection ##
+
+The following boolean variables indicate which \cgal components to
+configure and build. Their values can be ON or OFF.
+
+
+
+
+
+Variable
+
+Default value
+
+
+`WITH_examples`
+
+OFF
+
+
+`WITH_demos`
+
+OFF
+
+
+`WITH_CGAL_Core`
+
+ON
+
+
+`WITH_CGAL_Qt3`
+
+ON
+
+
+`WITH_CGAL_Qt4`
+
+ON
+
+
+`WITH_CGAL_ImageIO`
+
+ON
+
+
+
+
+## Compiler and Linker Flags ##
+
+The following variables specify compiler and linker flags. Each variable holds a
+space-separated list of command-line switches for the compiler and linker and
+their default values are automatically defined by CMake based on the target platform.
+
+Have in mind that these variables specify a list of flags, not just one
+single flag. If you provide your own definition for a variable, you will entirely override
+the list of flags chosen by CMake for that particular variable.
+
+The variables that correspond to both debug and release builds are always
+used in conjunction with those for the specific build type.
+
+
+
+
+
+Program
+
+Both Debug and Release
+
+Release only
+
+Debug Only
+
+
+C++ Compiler
+
+`CMAKE_CXX_FLAGS`
+
+`CMAKE_CXX_FLAGS_RELEASE`
+
+`CMAKE_CXX_FLAGS_DEBUG`
+
+
+Linker (shared libs)
+
+`CMAKE_SHARED_LINKER_FLAGS`
+
+`CMAKE_SHARED_LINKER_FLAGS_RELEASE`
+
+`CMAKE_SHARED_LINKER_FLAGS_DEBUG`
+
+
+Linker (static libs)
+
+`CMAKE_MODULE_LINKER_FLAGS`
+
+`CMAKE_MODULE_LINKER_FLAGS_RELEASE`
+
+`CMAKE_MODULE_LINKER_FLAGS_DEBUG`
+
+
+Linker (programs)
+
+`CMAKE_EXE_LINKER_FLAGS`
+
+`CMAKE_EXE_LINKER_FLAGS_RELEASE`
+
+`CMAKE_EXE_LINKER_FLAGS_DEBUG`
+
+
+
+
+## Additional Compiler and Linker Flags ##
+
+The following variables can be used to add flags without overriding the ones
+defined by cmake.
+
+
+
+
+
+Program
+
+Both Debug and Release
+
+Release only
+
+Debug Only
+
+
+C++ Compiler
+
+`CGAL_CXX_FLAGS`
+
+`CGAL_CXX_FLAGS_RELEASE`
+
+`CGAL_CXX_FLAGS_DEBUG`
+
+
+Linker (shared libs)
+
+`CGAL_SHARED_LINKER_FLAGS`
+
+`CGAL_SHARED_LINKER_FLAGS_RELEASE`
+
+`CGAL_SHARED_LINKER_FLAGS_DEBUG`
+
+
+Linker (static libs)
+
+`CGAL_MODULE_LINKER_FLAGS`
+
+`CGAL_MODULE_LINKER_FLAGS_RELEASE`
+
+`CGAL_MODULE_LINKER_FLAGS_DEBUG`
+
+
+Linker (programs)
+
+`CGAL_EXE_LINKER_FLAGS`
+
+`CGAL_EXE_LINKER_FLAGS_RELEASE`
+
+`CGAL_EXE_LINKER_FLAGS_DEBUG`
+
+
+
+
+## Miscellaneous Variables ##
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+Default value
+
+
+`CMAKE_BUILD_TYPE`
+
+Indicates type of build. Possible values are 'Debug' or 'Release'
+
+CMake
+
+Release
+
+
+`CMAKE_CXX_COMPILER`
+
+Full-path to the executable corresponding to the C++ compiler to use.
+
+CMake
+
+platform-dependent
+
+
+`CXX`
+
+Idem
+
+Environment
+
+Idem
+
+
+
+
+## Variables used only when building programs (such as demos or examples) ##
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+Default value
+
+
+`CGAL_DIR`
+
+Full-path to the binary directory where \cgal was configured
+
+Either CMake or Environment
+
+none
+
+
+
+
+## Variables providing information about 3rd-party libraries ##
+\anchor sec3partysoftwareconfig
+
+The following variables provide information about the availability and
+location of the 3rd party libraries used by \cgal. CMake automatically
+searches for dependencies so you need to specify these variables if
+CMake was unable to locate something. This is indicated by a value ending in
+`NOTFOUND`.
+
+Since 3rd-party libraries are system wide, many of the CMake variables listed below can alternatively
+be given as similarly-named environment variables instead. Keep in mind that you must provide one or the
+other but never both.
+
+## Boost libraries ##
+
+In most cases, if \sc{Boost} is not automatically found, setting the `BOOST_ROOT`
+variable is enough. If it is not, you can specify the header and library
+directories individually. You can also provide the full pathname to a specific compiled library
+if it cannot be found in the library directory or its name is non-standard.
+
+By default, when \sc{Boost} binary libraries are needed, the shared versions
+are used if present. You can set the variable
+`CGAL_Boost_USE_STATIC_LIBS` to `ON` if you want to link
+with static versions explicitly.
+
+On Windows, if you link with \sc{Boost} shared libraries, you must ensure that
+the `.dll` files are found by the dynamic linker, at run time.
+For example, you can add the path to the \sc{Boost} `.dll` to the
+`PATH` environment variable.
+
+
+
+Directory containing the `boost/version.hpp` file
+
+CMake
+
+
+`BOOST_INCLUDEDIR`
+
+Idem
+
+Environment
+
+
+`Boost_LIBRARY_DIRS`
+
+Directory containing the compiled \sc{Boost} libraries
+
+CMake
+
+
+`BOOST_LIBRARYDIR`
+
+Idem
+
+Environment
+
+
+`Boost_(xyz)_LIBRARY_RELEASE`
+
+Full pathname to a release build of the compiled 'xyz' \sc{Boost} library
+
+CMake
+
+
+`Boost_(xyz)_LIBRARY_DEBUG`
+
+Full pathname to a debug build of the compiled 'xyz' \sc{Boost} library
+
+CMake
+
+
+
+
+## Gmp and Mpfr libraries ##
+
+Under Windows, auto-linking is used, so only the directory
+containing the libraries is needed and you would specify `GMP|MPFR_LIBRARY_DIR` rather than
+`GMP|MPFR_LIBRARIES`. On the other hand, under Linux the actual library filename is needed.
+Thus you would specify `GMP|MPFR_LIBRARIES`. In no case you need to specify both.
+
+\cgal uses both \sc{Gmp} and \sc{Mpfr} so both need to be supported. If either of them is unavailable the
+usage of \sc{Gmp} and of \sc{Mpfr} will be disabled.
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`WITH_GMP`
+
+Indicates whether to search and use \sc{Gmp}/\sc{Mpfr} or not
+
+CMake
+
+
+`GMP_INCLUDE_DIR`
+
+Directory containing the `gmp.h` file
+
+CMake
+
+
+`GMP_INC_DIR`
+
+Idem
+
+Environment
+
+
+`GMP_LIBRARIES_DIR`
+
+Directory containing the compiled \sc{Gmp} library
+
+CMake
+
+
+`GMP_LIB_DIR`
+
+Idem
+
+Environment
+
+
+`GMP_LIBRARIES`
+
+Full pathname of the compiled \sc{Gmp} library
+
+CMake
+
+
+`MPFR_INCLUDE_DIR`
+
+Directory containing the `mpfr.h` file
+
+CMake
+
+
+`MPFR_INC_DIR`
+
+Idem
+
+Environment
+
+
+`MPFR_LIBRARIES_DIR`
+
+Directory containing the compiled \sc{Mpfr} library
+
+CMake
+
+
+`MPFR_LIB_DIR`
+
+Idem
+
+Environment
+
+
+`MPFR_LIBRARIES`
+
+Full pathname of the compiled \sc{Mpfr} library
+
+CMake
+
+
+
+
+Under Linux, the \sc{Gmpxx} is also searched for, and you may specify the following variables:
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`GMPXX_INCLUDE_DIR`
+
+Directory containing the `gmpxx.h` file
+
+CMake
+
+
+`GMPXX_LIBRARIES`
+
+Full pathname of the compiled \sc{Gmpxx} library
+
+CMake
+
+
+
+
+## Qt3 library ##
+
+In most cases, if \sc{Qt}3 is not automatically found, setting the `QTDIR`
+environment variable is sufficient. If it is not, you can specify the directory containing
+the header files and the full pathnames of the \sc{Qt}3 libraries.
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`QTDIR`
+
+Root directory of the \sc{Qt}3 library
+
+Environment
+
+
+`QT3_INCLUDE_DIR`
+
+Directory containing the `qt.h` file
+
+CMake
+
+
+`QT3_QT_LIBRARY`
+
+Full pathname to the qt library of \sc{Qt}3
+
+CMake
+
+
+`QT3_QTMAIN_LIBRARY`
+
+Full pathname to the qtmain library of \sc{Qt}3
+
+CMake
+
+
+`QT3_QASSISTANTCLIENT_LIBRARY`
+
+Full pathname to the qassistantclient library of \sc{Qt}3
+
+CMake
+
+
+`QT3_MOC_EXECUTABLE`
+
+Full pathname to the moc executable of \sc{Qt}3
+
+CMake
+
+
+`QT3_UIC_EXECUTABLE`
+
+Full pathname to the uic executable of \sc{Qt}3
+
+CMake
+
+
+
+
+## Qt4 library ##
+
+The CMake scripts that search for \sc{Qt}4 can use the introspection feature
+of the tool `qmake` included in \sc{Qt}4 distributions. If \sc{Qt}4 is not
+automatically found, it is sufficient to set the `PATH`
+environment variable, so that \sc{Qt}4 `qmake` tool is in the path, and
+before \sc{Qt}3 `qmake` if that one exists. One can alternatively set the
+CMake variable `QT_QMAKE_EXECUTABLE`. The following variables
+should be then assigned automatically by CMake.
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`QT_INCLUDE_DIR`
+
+Directory containing the `QtCore/qglobal.h` file
+
+CMake
+
+
+`QT_LIBRARY_DIR`
+
+Directory containing the compiled \sc{Qt}4 libraries
+
+CMake
+
+
+`QT_(xyz)_LIBRARY`
+
+Full pathname to the compiled 'xyz' \sc{Qt}4 library17
+
+CMake
+
+
+`QT_QMAKE_EXECUTABLE`
+
+Full pathname to the qmake executable of \sc{Qt}4
+
+CMake
+
+
+`QT_MOC_EXECUTABLE`
+
+Full pathname to the moc executable of \sc{Qt}4
+
+CMake
+
+
+`QT_UIC_EXECUTABLE`
+
+Full pathname to the uic executable of \sc{Qt}4
+
+CMake
+
+
+
+
+## Leda library ##
+
+When the \leda libraries are not automatically found, yet they are installed on the system
+with base names 'leda' and 'ledaD' (for the release and debug versions resp.), it might
+be sufficient to just indicate the library directory via the `LEDA_LIBRARY_DIRS` variable.
+If that doesn't work because, for example, the names are different, you can provide the full pathnames of each variant
+via `LEDA_LIBRARY_RELEASE` and `LEDA_LIBRARY_DEBUG`.
+
+The variables specifying definitions and flags can be left undefined if they are not needed by LEDA.
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`WITH_LEDA`
+
+Indicates whether to search and use \leda or not
+
+CMake
+
+
+`LEDA_INCLUDE_DIR`
+
+Directory containing the file `LEDA/system/basic.h`
+
+CMake
+
+
+`LEDA_LIBRARIES`
+
+Directory containing the compiled \leda libraries
+
+CMake
+
+
+`LEDA_INC_DIR`
+
+Directory containing the file `LEDA/system/basic.h`
+
+Environment
+
+
+`LEDA_LIB_DIR`
+
+Directory containing the compiled \leda libraries
+
+Environment
+
+
+`LEDA_LIBRARY_RELEASE`
+
+Full pathname to a release build of the \leda library
+
+Either CMake
+
+
+`LEDA_LIBRARY_DEBUG`
+
+Full pathname to a debug build of the \leda library
+
+Either CMake
+
+
+`LEDA_DEFINITIONS`
+
+Preprocessor definitions
+
+Either CMake
+
+
+`LEDA_CXX_FLAGS`
+
+Compiler flags
+
+Either CMake
+
+
+`LEDA_LINKER_FLAGS`
+
+Linker flags
+
+Either CMake
+
+
+
+
+## Mpfi library ##
+
+\cgal provides a number type based on this library, but the \cgal library
+itself does not depend on \sc{Mpfi}. This means that this library must be
+configured when compiling an application that uses the above number type.
+
+When \sc{Mpfi} files are not on the standard path, the locations of the headers
+and library files must be specified by using environment variables.
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`MPFI_INCLUDE_DIR`
+
+Directory containing the `mpfi.h` file
+
+CMake
+
+
+`MPFI_INC_DIR`
+
+Idem
+
+Environment
+
+
+`MPFI_LIBRARIES_DIR`
+
+Directory containing the compiled \sc{Mpfi} library
+
+CMake
+
+
+`MPFI_LIB_DIR`
+
+Idem
+
+Environment
+
+
+`MPFI_LIBRARIES`
+
+Full pathname of the compiled \sc{Mpfi} library
+
+CMake
+
+
+
+
+## Rs and Rs3 library ##
+
+As said before, only the \cgal univariate algebraic kernel depends on the
+library Rs. As the algebraic kernel is not compiled as a part of the \cgal
+library, this library is not detected nor configured at installation time.
+
+CMake will try to find Rs in the standard header and library
+directories. When it is not automatically detected, the locations of the
+headers and library files must be specified using environment variables.
+
+Rs needs \sc{Gmp} 4.2 or later and \sc{Mpfi} 1.3.4 or later. The variables
+related to the latter library may also need to be defined.
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`RS_INCLUDE_DIR`
+
+Directory containing the `rs_exports.h` file
+
+CMake
+
+
+`RS_INC_DIR`
+
+Idem
+
+Environment
+
+
+`RS_LIBRARIES_DIR`
+
+Directory containing the compiled Rs library
+
+CMake
+
+
+`RS_LIB_DIR`
+
+Idem
+
+Environment
+
+
+`RS_LIBRARIES`
+
+Full pathname of the compiled Rs library
+
+CMake
+
+
+
+
+Similar variables exist for Rs3.
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`RS3_INCLUDE_DIR`
+
+Directory containing the `rs_exports.h` file
+
+CMake
+
+
+`RS3_INC_DIR`
+
+Idem
+
+Environment
+
+
+`RS3_LIBRARIES_DIR`
+
+Directory containing the compiled Rs library
+
+CMake
+
+
+`RS3_LIB_DIR`
+
+Idem
+
+Environment
+
+
+`RS3_LIBRARIES`
+
+Full pathname of the compiled Rs library
+
+CMake
+
+
+
+
+## Ntl library ##
+
+Some polynomial computations in \cgal's algebraic kernel
+are speed up when \sc{Ntl} is available.
+As the algebraic kernel is not compiled as a part of the \cgal
+library, this library is not detected nor configured at installation time.
+
+CMake will try to find \sc{Ntl} in the standard header and library
+directories. When it is not automatically detected, the locations of the
+headers and library files must be specified using environment variables.
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`NTL_INCLUDE_DIR`
+
+Directory containing the `NTL/ZZX.h` file
+
+CMake
+
+
+`NTL_INC_DIR`
+
+Idem
+
+Environment
+
+
+`NTL_LIBRARIES_DIR`
+
+Directory containing the compiled \sc{Ntl} library
+
+CMake
+
+
+`NTL_LIB_DIR`
+
+Idem
+
+Environment
+
+
+`NTL_LIBRARIES`
+
+Full pathname of the compiled \sc{Ntl} library
+
+CMake
+
+
+
+
+## Eigen library ##
+
+\sc{Eigen} is a header-only template library.
+Only the directory containing the header files of \sc{Eigen} 3.1 (or greater) is needed.
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`EIGEN3_INCLUDE_DIR`
+
+Directory containing the file `signature_of_eigen3_matrix_library`
+
+CMake
+
+
+`EIGEN3_INC_DIR`
+
+Idem
+
+Environment
+
+
+
+
+## QGLViewer library ##
+
+Some demos require the GLViewer library.
+
+In most cases, if QGLViewer is not automatically found, setting the `QGLVIEWERROOT`
+environment variable is sufficient. If it is not, you can specify the directory containing
+the header files and the full pathnames of the release and debug libraries
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`QGLVIEWERROOT`
+
+Root directory of the QGLViewer library
+
+Environment
+
+
+`QGLVIEWER_INCLUDE_DIR`
+
+Directory containing the `QGLViewer/qglviewer.h` file
+
+CMake
+
+
+`QGLVIEWER_LIBRARY_RELEASE`
+
+Full pathname to a release build of the QGLViewer library
+
+CMake
+
+
+`QGLVIEWER_LIBRARY_DEBUG`
+
+Full pathname to a debug build of the QGLViewer library
+
+CMake
+
+
+
+
+## ESBTL library ##
+
+One skin surface example requires the ESBTL library in order to read \sc{Pdb} files.
+
+If ESBTL is not automatically found, setting the `ESBTL_INC_DIR`
+environment variable is sufficient.
+
+
+
+
+
+Variable
+
+Description
+
+Type
+
+
+`ESBTL_INC_DIR`
+
+Directory containing the `ESBTL/default.h` file
+
+Environment
+
+
+`ESBTL_INCLUDE_DIR`
+
+Directory containing the `ESBTL/default.h` file
+
+CMake
+
+
+
+
+# Compiler Workarounds #
+
+A number of boolean flags are used to workaround compiler bugs and
+limitations. They all start with the prefix `CGAL_CFG`. These
+flags are used to work around compiler bugs and limitations. For
+example, the flag `CGAL_CFG_NO_CPP0X_LONG_LONG` denotes
+that the compiler does not know the type `long long`.
+
+For each installation a file
+is defined, with the correct
+settings of all flags. This file is generated automatically by CMake,
+and it is located in the `include` directory of where you run
+CMake. For an in-source configuration this means
+`CGAL-x.y/include`.
+
+The test programs used to generate the `compiler_config.h`
+file can be found in `config/testfiles`.
+Both
+`compiler_config.h` and the test programs contain a short
+description of the problem. In case of trouble with one of the
+`CGAL_CFG` flags, it is a good idea to take a look at it.
+
+The file `CGAL/compiler_config.h` is included from
+``.
+which is included by all \cgal header files.
+
+\section seccompileroptimisations Compiler Optimizations
+
+By default CMake generates makefiles for Release mode, with
+optimization flags switched on, and vcproj files for Release
+and Debug modes.
+
+*/
+} /* namespace CGAL */
diff --git a/Documentation/doxyassist.xml b/Documentation/doxyassist.xml
index d833cc4efca..d994041969b 100644
--- a/Documentation/doxyassist.xml
+++ b/Documentation/doxyassist.xml
@@ -40,6 +40,7 @@ namespace for the XML file to be processed properly. -->
PkgDescriptionBegin{1}=<table cellpadding="2" cellspacing="0"><tr><td colspan="2"></td></tr><tr>PkgManuals{2}=
+ header_package.html
@@ -1289,6 +1290,8 @@ namespace for the XML file to be processed properly. -->
*/doc/Developer_manual/*
+ header.html
+
DoxygenLayout.xml./tags/Manual.tag../Convex_hull_2/examples
diff --git a/Documentation/header.html b/Documentation/header.html
index 8de37754689..60f053fc9a6 100644
--- a/Documentation/header.html
+++ b/Documentation/header.html
@@ -11,35 +11,6 @@
$treeview
$search
-
-
-
diff --git a/Documentation/header_package.html b/Documentation/header_package.html
new file mode 100644
index 00000000000..8de37754689
--- /dev/null
+++ b/Documentation/header_package.html
@@ -0,0 +1,149 @@
+
+
+
+
+
+$projectname: $title
+$title
+
+
+
+
+$treeview
+$search
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+$extrastylesheet
+
+
+\( \newcommand{\E}{\mathrm{E}} \) \( \newcommand{\A}{\mathrm{A}} \)
+\( \newcommand{\R}{\mathrm{R}} \) \( \newcommand{\N}{\mathrm{N}} \) \( \newcommand{\Q}{\mathrm{Q}} \) \( \newcommand{\Z}{\mathrm{Z}} \)
+\(
+\def\ccSum #1#2#3{
+ \sum_{#1}^{#2}{#3}
+}
+
+\def\ccProd #1#2#3{
+ \sum_{#1}^{#2}{#3}
+}\)
+
+
+