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

Merge branch 'Mesh_3-add_random_generator_to_mesh_domain-GF' into Mesh_3-compare_index-GF

This commit is contained in:
Jane Tournois 2014-03-28 11:01:40 +01:00
parent 78e9d70b19 1e7633d863
commit 1b0323c8b8
136 changed files with 7846 additions and 1321 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
Arrangement_on_surface_2/polyline_upgrade_submission+summary/doc-setting.sty
View File

@ -1,67 +0,0 @@
% Style and command for the document
%
% Dror Atariah, 18.04.2013
%
\NeedsTeXFormat{LaTeX2e}[1994/06/01]
\ProvidesPackage{doc-setting}
%
% Packages in use
%%%%%%%%%%%%%%%%%%%
\RequirePackage{mathptmx}
\RequirePackage[T1]{fontenc}
\RequirePackage[utf8x]{inputenc}
\RequirePackage[english]{babel}
\RequirePackage{microtype}
\RequirePackage{hyperref}
\RequirePackage{amsthm,amsmath}
\RequirePackage{graphicx}
\RequirePackage{xcolor}
\RequirePackage{xspace}
\RequirePackage{todonotes}
\RequirePackage{verbments}
\RequirePackage{lscape}
\RequirePackage{standalone}
\RequirePackage{enumitem}
\setlist{noitemsep,topsep=0pt,parsep=0pt,partopsep=0pt}
\RequirePackage{tikz}
\usetikzlibrary{decorations.markings,arrows,calc}
\newcommand*{\cgal}{\textbf{\textsc{Cgal}}\xspace}
\newcommand*{\file}[1]{\textit{\texttt{#1}}}
\newcommand*{\concept}[1]{\textsc{#1}}
\newcommand*{\model}[1]{\textit{#1}}
\newcommand*{\type}[1]{\texttt{#1}}
\newcommand*{\code}[1]{\texttt{#1}}
\newcommand*{\functor}[1]{\textsf{#1}}
\newcommand*{\seg}{{\color{blue}\type{Segment}}\xspace}
\newcommand*{\segtr}{{\color{red}\model{Segment\_traits}}\xspace}
\newcommand*{\polytr}{{\color{red}\model{Polyline\_traits}}\xspace}
\newcommand*{\poly}{{\color{blue}\type{Polyline}}\xspace}
\newcommand*{\xpoly}{{\color{blue}\type{X-Polyline}}\xspace}
\usepackage[framemethod=tikz]{mdframed}
\theoremstyle{definition}
\newtheorem{que}{Question}
% \newenvironment{queframe}%
% {\begin{mdframed}[backgroundcolor=lightgray]\begin{que}}%
% {\end{que}\end{mdframed}}
\newmdtheoremenv[%
backgroundcolor=red!10,%
outerlinecolor=black,%
innertopmargin = \topskip,%
splittopskip = \topskip,%
ntheorem = true,%
skipabove = \baselineskip,%
skipbelow = \baselineskip,%
roundcorner=4]
{queframe}{Question}
\RequirePackage[capitalise]{cleveref}
\endinput

BIN
Arrangement_on_surface_2/polyline_upgrade_submission+summary/figures/intersect.pdf
View File

Binary file not shown.

100
Arrangement_on_surface_2/polyline_upgrade_submission+summary/figures/intersect.tex
View File

@ -1,100 +0,0 @@
\documentclass{standalone}
\usepackage{tikz}
\usetikzlibrary{calc}
\begin{document}
\begin{tikzpicture}
\def\sep{0.15}
\def\scalefact{8}
\def\scalerad{\scalefact*1pt}
\tikzset{
ncbar/.style={
to path=%
($(\tikztostart)!#1!90:(\tikztotarget)$)
-- ($(\tikztotarget)!($(\tikztostart)!#1!90:(\tikztotarget)$)!90:(\tikztostart)$)
(\tikztotarget) \tikztonodes
},
ncbar/.default=0.5cm,
}
\tikzset{%
polyline/.style={%
ultra thick, -latex, shorten <= \scalerad, shorten >= \scalerad}}
% \draw[help lines,step=\scalefact] (0,0) grid ($(4*\scalefact ,2*\scalefact)$);
\foreach \i in {0,1,2,3,4}
\foreach \j in {0,1,2}{
\coordinate (p\i\j) at ($(\scalefact*\i,\scalefact*\j)$);
\fill (p\i\j) circle (\scalerad);
}
\draw[polyline] ($(p00)+(\sep,0)$) --node[near end,below]{0} ($(p11)+(0,-\sep)$);
\draw[polyline] ($(p02)+(0,-\sep)$) -- node[near end, below]{1} ($(p11)+(-\sep,0)$);
\draw[polyline] ($(p11)+(\sep,0)$) -- node[near start, below]{2} ($(p22)+(0,-\sep)$);
\draw[polyline] ($(p11)+(0,-\sep)$) -- node[near start, below]{3} ($(p20)+(-\sep,0)$);
\draw[polyline] ($(p11)+(-\sep,0)$) --node[near start,above]{4} ($(p00)+(0,\sep)$);
\draw[polyline] ($(p11)+(0,\sep)$) -- node[near start, above]{5} ($(p02)+(\sep,0)$);
\draw[polyline] ($(p22)+(-\sep,0)$) -- node[near end, above]{6} ($(p11)+(0,\sep)$);
\draw[polyline] ($(p20)+(0,\sep)$) -- node[near end, above]{7} ($(p11)+(\sep,0)$);
\draw[polyline] ($(p10)+(\sep,0)$) -- node[near start, right]{8} ($(p11)+(\sep,-2*\sep)$);
\draw[polyline] ($(p11)+(\sep,2*\sep)$) -- node[near end, right]{9} ($(p12)+(\sep,0)$);
\draw[polyline] ($(p11)+(-\sep,-2*\sep)$) -- node[near end, left]{10} ($(p10)+(-\sep,0)$);
\draw[polyline] ($(p12)+(-\sep,0)$) -- node[near start, left]{11} ($(p11)+(-\sep,2*\sep)$);
\draw[polyline,magenta] ($(p00)+(4*\sep,0)$) -- ($(p11)+(2*\sep,-2*\sep)$) -- ($(p22)+(0,-4*\sep)$) node[above right]{12};
\fill[magenta] ($(p11)+(2*\sep,-2*\sep)$) circle (\sep);
\draw[polyline,magenta] ($(p02)+(0,-4*\sep)$) -- ($(p11)+(-2*\sep,-2*\sep)$) -- node[near end, below]{13} ($(p20)+(-4*\sep,0)$);
\fill[magenta] ($(p11)+(-2*\sep,-2*\sep)$) circle (\sep);
\draw[polyline,blue] ($(p00)+(6*\sep,0)$) -- ($(p11)+(0,-6*\sep)$) -- node[at end, below]{14} ($(p20)+(-6*\sep,0)$);
\draw[polyline,blue] ($(p02)+(6*\sep,0)$) -- ($(p11)+(0,6*\sep)$) -- node[at end, above]{15} ($(p22)+(-6*\sep,0)$);
\draw[polyline,magenta] ($(p22)+(-4*\sep,0)$) -- ($(p11)+(-2*\sep,2*\sep)$) -- node[near end, above]{16} ($(p00)+(0,4*\sep)$);
\fill[magenta] ($(p11)+(-2*\sep,2*\sep)$) circle (\sep);
\draw[polyline,magenta] ($(p20)+(0,4*\sep)$) -- ($(p11)+(2*\sep,2*\sep)$) -- ($(p02)+(4*\sep,0)$) node[above]{17};
\fill[magenta] ($(p11)+(2*\sep,2*\sep)$) circle (\sep);
\draw[polyline,blue] ($(p20)+(-8*\sep,0)$) -- ($(p11)+(0,-8*\sep)$) -- node[at end, below] {18} ($(p00)+(8*\sep,0)$);
\draw[polyline,blue] ($(p22)+(-8*\sep,0)$) -- ($(p11)+(0,8*\sep)$) -- node[at end, above] {19} ($(p02)+(8*\sep,0)$);
\draw[polyline,green] ($(p00)+(10*\sep,0)$) -- ($(p22)+(0,-10*\sep)$) -- ($(p40)+(-10*\sep,0)$) node[below] {20};
\draw[polyline,green] ($(p40)+(0,10*\sep)$) -- ($(p22)+(0,10*\sep)$) -- ($(p00)+(0,10*\sep)$) node[below] {21};
\draw[polyline,green,dashed] ($(p02)+(10*\sep,0)$) -- ($(p20)+(0,10*\sep)$) -- ($(p42)+(-10*\sep,0)$) node[above] {22};
\draw[polyline,green,dashed] ($(p42)+(0,-10*\sep)$) -- ($(p20)+(0,-10*\sep)$) -- ($(p02)+(0,-10*\sep)$) node[above] {23};
\draw[polyline,yellow!50!black] ($(p00)+(12*\sep,0)$) -- ($(p11)+(0,-12*\sep)$) -- ($(p20)+(0,-12*\sep)$) -- ($(p31)+(0,-12*\sep)$) -- ($(p40)+(-12*\sep,0)$) node[below left]{24};
\draw[polyline,yellow!50!black] ($(p40)+(0,12*\sep)$) -- ($(p31)+(0,12*\sep)$) -- ($(p20)+(0,12*\sep)$) -- ($(p11)+(0,12*\sep)$) -- ($(p00)+(0,12*\sep)$) node[above]{25};
\draw[polyline,yellow!50!black,dashed] ($(p02)+(14*\sep,0)$) -- ($(p11)+(0,14*\sep)$) -- ($(p22)+(0,14*\sep)$) -- ($(p31)+(0,14*\sep)$) -- ($(p42)+(-14*\sep,0)$) node[above]{28};
\draw[polyline,yellow!50!black,dashed] ($(p42)+(0,-14*\sep)$) -- ($(p31)+(0,-14*\sep)$) -- ($(p22)+(0,-14*\sep)$) -- ($(p11)+(0,-14*\sep)$) -- ($(p02)+(0,-14*\sep)$) node[below]{29};
\draw[polyline,gray] ($(p31)$) -- node[near end,above]{26} ($(p40)$);
\draw[polyline,gray] ($(p11)+(6*\sep,0)$) -- ($(p20)+(0,6*\sep)$) -- node[near end, below]{27} ($(p31)+(-6*\sep,0)$);
\draw[polyline,gray] ($(p31)$) -- node[near end,above]{30} ($(p42)$);
\draw[polyline,gray] ($(p11)+(6*\sep,0)$) -- ($(p22)+(0,-6*\sep)$) -- node[near end, above] {31} ($(p31)+(-6*\sep,0)$);
\draw[polyline,orange] ($(p00)+(-2*\sep,0)$) -- node[near end,right]{32} ($(p02)+(-2*\sep,0)$);
\draw[polyline,orange] ($(p02)+(-4*\sep,0)$) -- node[near end,left]{33} ($(p00)+(-4*\sep,0)$);
\draw[polyline,orange] ($(p10)+(5*\sep,0)$) -- node[near end,right]{34} ($(p12)+(5*\sep,0)$);
\draw[polyline,orange] ($(p12)+(-5*\sep,0)$) -- node[near end,left]{35} ($(p10)+(-5*\sep,0)$);
\draw[polyline,orange] ($(p20)+(4*\sep,0)$) -- node[near end,right]{36} ($(p22)+(4*\sep,0)$);
\draw[polyline,orange] ($(p22)+(-4*\sep,0)$) -- node[near end,left]{37} ($(p20)+(-4*\sep,0)$);
\draw[polyline,orange] ($(p30)+(2*\sep,0)$) -- node[near end,right]{38} ($(p32)+(2*\sep,0)$);
\draw[polyline,orange] ($(p32)+(-2*\sep,0)$) -- node[near end,left]{39} ($(p30)+(-2*\sep,0)$);
\draw[polyline,orange] ($(p40)+(2*\sep,0)$) -- node[near end,left]{40} ($(p42)+(2*\sep,0)$);
\draw[polyline,orange] ($(p42)+(4*\sep,0)$) -- node[near end,right]{41} ($(p40)+(4*\sep,0)$);
\end{tikzpicture}
\end{document}
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "../main"
%%% End:

457
Arrangement_on_surface_2/polyline_upgrade_submission+summary/main.tex
View File

@ -1,457 +0,0 @@
\documentclass[a4paper,10pt]{article}
\usepackage[scale=0.7,vmarginratio={1:2},heightrounded]{geometry}
\catcode`_=\active
\newcommand{_}{\ifmmode\expandafter\sbrm\else\string_\fi}
\newcommand{\sbrm}[1]{\sb{\mathrm{#1}}}
\usepackage{doc-setting}
\title{Arrangement of Polylines Traits Class - Upgrade}
\author{Dror Atariah}
\begin{document}
\maketitle
\begin{abstract}
Outline the projects goals and progress.
\end{abstract}
\section{Introduction}
\label{sec:introduction}
The implementation of the computation of arrangement of polylines shipped with version 4.2 of \cgal proved to poses limitations.
For example, the only way it provides to construct a polyline is by giving a range of points as its input.
Another example would be that inspecting an existing polyline, in terms of iterating over its elements, is only possible by iterating over its \emph{vertices}.
These two main limitations, among others, turn it difficult to generalize the implementation --- for example when attempting to compute the arrangement of \emph{unbounded} polylines.
In addition, as the core of the code is several years old, it no longer meets the standards of \cgal.
Therefore, the goal of this project is, as a first step, to upgrade and update the code that deals with polylines in the Arrangement on Surface (AoS) package.
This upgrade lay the foundation for future generalization of the class.
In addition, by adopting better programming style we also manage to introduce an improvement of 4--6\% in the performance of the package.
\subsection{Notations Conventions}
\label{sec:notat-conv}
We use the following typesetting convention.
\begin{itemize}
\item \file{foo.bar} is a file name.
\item A concept is \concept{ConceptName} and its model is \model{Concept_name_model}.
\item \type{Some_type} will indicate a type and \functor{My_functor} will indicate a function class (a.k.a. functor).
\end{itemize}
\subsection{Definitions}
\label{sec:definitions}
%
Furthermore, we will use the following, more specific, conventions:
\begin{itemize}
%
\item \href{http://doc.cgal.org/4.2/CGAL.CGAL.2D-Arrangements/html/classCGAL_1_1Arr__polyline__traits__2.html}{\polytr} is the polyline traits class which currently models the following concepts:
\begin{itemize}
\item \concept{ArrangementTraits\_2}
\item \concept{ArrangementLandmarkTraits\_2}
\end{itemize}
Its implementation can be found in \file{Arr\_polyline\_traits\_2.h}.
This traits class has two nested types \poly and \xpoly which are the \type{Curve\_2} and \type{X\_monotone\_curve\_2} nested types of the traits class.
These curves are the representations of piecewise linear (PL) curves and x-monotone PL curves respectively.
\polytr, together with its nested curve types, is the component of the arrangement on surfaces package of \cgal which handles the construction and computations of arrangements of sets of polylines.
The actual implementations of \poly and \xpoly can be found in \file{Polyline\_2.h}.
%
\item The \concept{SegmentTraits} is the template parameter of the \polytr and it should be a model of \concept{ArrangementTraits\_2}.
Currently there are two implementations of models of \concept{SegmentTraits}:
\begin{itemize}
\item \model{Arr\_segment\_traits\_2}
\item \model{Arr\_non\_caching\_segment\_traits\_2}
\end{itemize}
When there is no place of confusion we shall refer to them as \segtr.
In addition, \segtr models the concepts:
\begin{itemize}
\item \concept{ArrangementTraits\_2}
\item \concept{ArrangementLandmarkTraits\_2}
\item \concept{ArrangementDirectionalXMonotoneTraits\_2}
\end{itemize}
For example, \model{Arr_segment_traits_2} is implemented in \file{Arr\_segment\_traits\_2.h}.
Let \seg be the \type{Curve\_2} and \type{X\_monotone\_curve\_2} nested types that are nested in \segtr.
\end{itemize}
\section{Implementation of \poly and \xpoly}
\label{sec:implementation-poly}
The implementations of \poly and \xpoly are the building blocks of the polyline traits class and the way we could compute arrangement of polylines.
The existing implementation of the types is rather old and no longer meets the standards of \cgal.
Furthermore, as we discuss later, the implementation is restrictive and cannot serve in an attempt to generalize the package to support \emph{unbounded polylines}.
Therefore, this implementation had to be revised and we discuss this revision in this section.
\paragraph{Degenerated polylines.}
\label{sec:degen-polyl-construction}
The \segtr does not allow the construction of degenerated polylines.
In turn, we impose a similar constrain on the construction of \poly and \xpoly, namely we exclude the construction of degenerated polylines.
That is we do not treat polylines which contains degenerated segments (i.e. segments of length zero) and isolated points.
\paragraph{Well oriented polylines.}
\label{sec:well-orient-polyl}
From a strictly mathematical point of view, polylines do not induce any notion of orientation.
Here orientation is in the sense of source or start of a polyline and its target or end.
The only restriction is that the constituting segments will concatenate properly and form a PL curve.
Similarly, the segments, again from a mathematical point of view, may not be directed.
However, the both implementations of models of \concept{SegmentTraits} model the concept \concept{ArrangementDirectionalXMonotoneTraits_2}.
In other words they provide the notion of both \emph{source} and \emph{target}.
The source and target of a segment can be determined using the functors
\begin{itemize}
\item \functor{Compare\_endpoints\_xy\_2}
\item \functor{Construct\_opposite\_2}
\end{itemize}
which are provided by \concept{ArrangementDirectionalXMonotoneTraits_2} together with the functors
\begin{itemize}
\item \functor{Construct\_min\_vertex\_2}
\item \functor{Construct\_max\_vertex\_2}
\end{itemize}
which are defined in the concept \concept{ArrangementTraits_2}.
Furthermore, two access function \code{source()} and \code{target()} are provided by \segtr.
Note that these functions are \emph{not} required by the concepts which \segtr models.
Nevertheless, current implementation of \poly and \xpoly used these function extensively.
Obviously this is bad programming style.
In order to keep the efficiency benefits of the usage of \code{source()} and \code{target()} on one hand and consistency with the documentation on the other, we add a requirement that \segtr should be model of the \concept{ArrangementDirectionalXMonotoneTraits\_2}.
Note that this assumption implies only a conceptual restriction, since in practice the available implementations that can be used model this concept anyway.
Once \segtr models this concept we can remove all occurrences of \code{source()} and \code{target()}.
In this we assert that \polytr itself will be a model of this concept as well.
As a result, we can also provide the following invariant: \textbf{\poly and \xpoly will be \emph{well oriented}.}
That is, the \emph{source} of the \(n\)-th \seg should be the \emph{target} of the \((n-1)\)-th \seg.
In particular the polyline:
\begin{center}
\begin{tikzpicture}
\begin{scope}[thick]
\draw (-2,0) coordinate (a1) -- (-1,1) coordinate (a2);
\draw (0,0) coordinate (a3) -- (a2);
\draw (1,1) coordinate (a4) -- (a3);
\draw (a4) -- (-0.25,0.75) coordinate (a5);
\foreach \i in {1,2,3,4,5}
\fill (a\i) circle (2pt);
\end{scope}
\end{tikzpicture}
\end{center}
can now be represented as one and only one of the following:
\begin{center}
\begin{tikzpicture}
\begin{scope}[thick,decoration={%
markings,
mark=at position 0.5 with {\arrow{>}}%
}]
\coordinate (a1) at (-2,0);
\coordinate (a2) at (-1,1);
\coordinate (a3) at (0,0);
\coordinate (a4) at (1,1);
\coordinate (a5) at (-0.25,0.75);
\draw[postaction={decorate}] (a1) -- (a2);
\draw[postaction={decorate}] (a2) -- (a3);
\draw[postaction={decorate}] (a3) -- (a4);
\draw[postaction={decorate}] (a4) -- (a5);
\foreach \i in {1,2,3,4,5}
\fill (a\i) circle (2pt);
\end{scope}
%
\begin{scope}[xshift=4cm,thick,decoration={%
markings,
mark=at position 0.5 with {\arrow{>}}%
}]
\coordinate (a1) at (-2,0);
\coordinate (a2) at (-1,1);
\coordinate (a3) at (0,0);
\coordinate (a4) at (1,1);
\coordinate (a5) at (-0.25,0.75);
\draw[postaction={decorate}] (a2) -- (a1);
\draw[postaction={decorate}] (a3) -- (a2);
\draw[postaction={decorate}] (a4) -- (a3);
\draw[postaction={decorate}] (a5) -- (a4);
\foreach \i in {1,2,3,4,5}
\fill (a\i) circle (2pt);
\end{scope}
\end{tikzpicture}
\end{center}
\paragraph{Direction invariant of \(x\)-monotone polylines.}
\label{sec:direct-invar-x-mono-poly}
An \xpoly is x-monotone regardless of its representation.
X-monotonicity is a geometrical property of the polyline, and it is not by its internal representation.
Currently, an \xpoly maintains a \emph{direction invariant} that it is oriented \emph{left-to-right}.
That is, its vertices should be given in an increasing lexicographic order.
However, in general an \xpoly should merely be x-monotone, and its vertices (or segments) may be oriented from left-to-right \emph{or} from right-to-left.
In this project we lifted this restriction and the new implementation allows the construction of \xpoly's which are oriented either left-to-right \emph{or} right-to-left.
\paragraph{Accessing the traits class from nested types.}
\label{sec:access-traits-class-from-nested-types}
\cgal's style discourages the usage of functors from traits classes inside nested types.
The current implementation violated this style.
Therefore all cases where functors of either \polytr or \segtr were used inside \poly and \xpoly were removed.
This includes removing code which was in \code{CGAL_precondition}.
\paragraph{Name spaces.}
\label{sec:name-spaces-poly+xpoly}
The implementation of \poly and \xpoly was moved into its own namespace, namely \code{POLYLINE}.
\paragraph{Construction and Iteration.}
\label{sec:constr+iter-poly}
The current implementation of \poly and \xpoly emph{relays on their vertices} and it is only possible to construct the from a given range of \emph{points}.
Furthermore, given either a \poly or \xpoly, it is only possible to iterate over its vertices.
There is no way to iterate over the segments that constitute the polyline.
This design limits the possibilities of extending the traits class, for example to enable the handling of unbounded polylines.
\subparagraph{Construction.}
In order to enable construction of unbounded polylines, we have to add the possibility of construction from ranges of \seg's.
Ultimately, there will be \emph{only} one constructor of either \poly's or \xpoly's.
This construction will construct the polyline \emph{only} from ranges of \seg's.
For the sake of backwards compatibility, the current constructor, namely the one from a range of points, will be kept as deprecated\footnote{In the next version it will be removed completely.}.
The user should be encouraged to use the construction functors from \polytr (see \cref{sec:constr-funct-polytr}) and not the direct constructor of the class.
The functors provide the construction from two points, one segment, range of points and range of segments.
\subparagraph{Iteration.}
As we pointed out, iteration over the vertices of the polyline is restrictive.
We thus replace the iterators over the vertices which are currently defined for \poly and \xpoly with iterators over the segments of \poly and \xpoly respectively.
The iterators over the segments are obtained directly from the container of the \seg's.
Note that due to this change all the occurrences of iterators over the points of either a \poly or an \xpoly in \polytr have to be replaced with the iterators over their respective segments.
\paragraph{Augmenting a polyline}
\label{sec:augmenting-poly}
Currently, a polyline can be augmented using a \emph{push-back} function.
This function works as follows:
\begin{enumerate}
\item Gets a vertex as its input.
\item Obtains the last vertex of the polyline using \code{target()} function.
\item Generates a new \seg and pushes it to the range of segments representing the \poly.
\end{enumerate}
As we already mentioned, using a function like \code{target()} has to be avoided.
Furthermore, in order to maintain the well-orientedness of the polylines \segtr has to be used; again this is not desired
Augmenting an existing polyline will be treated, from now on, using the functor \functor{Push_back_2} (See \cref{sec:augmenting-poly-in-polytr}).
\section{Changes and updates of \polytr}
\label{sec:impl-polytr}
Ultimately, the \polytr should be in charge of all the operations which deal with \poly's and \xpoly's.
To that end, the traits class should provide functors which construct, augment, split etc. polylines.
\subsection{Construction Functors}
\label{sec:constr-funct-polytr}
As we leave only one constructor (which handles a range of \seg's) in the class of \poly and \xpoly we have to provide other needed construction methods in the traits class, namely in \polytr.
To that end we provide two functors \functor{Construct_curve_2} and \functor{Construct_x_monotone_curve_2} which returns either a \poly or \xpoly object respectively.
The \code{operator()} of these functors is overloaded so it can treat various types of inputs.
In particular we provide the following overloads in the \functor{Construct_curve_2}
\begin{pyglist}[language=c++]
Curve_2 operator()(const Point_2& p, const Point_2& q) const
Curve_2 operator()(const Segment_2& seg) const
Curve_2 operator()(ForwardIterator begin, ForwardIterator end) const
\end{pyglist}
\noindent
The last functor dispatches the given range to the corresponding implementation depending on the \emph{type} of the elements of the given range.
Similar functors are provided for the construction of \xpoly.
All validity tests of the input should be done in \code{CGAL\_precondition} blocks.
\subsection{Augmenting a \poly or \xpoly}
\label{sec:augmenting-poly-in-polytr}
We added the functor \functor{Push_back_2} which augment either an existing \poly or \xpoly.
Note that ideally, the user would not have to use augment an \xpoly manually.
The functor is able to append either vertices or segments to an \emph{existing} (\(x\)-monotone) polyline.
Note that once the polyline will be unbounded augmentation will not be always possible.
\subsection{Output of \functor{Intersect\_2}}
\label{sec:outp-funct-intersect-2}
In the concept \concept{ArrTraits::Intersect\_2} it is defined that the output iterator should contain the elements in an ascending \(xy\)-lexicographic order.
Thus, obviously, the implementation of \functor{Intersect\_2} had to be updated one the left-to-right invariant was lifted.
\subsection{Location Functions}
\label{sec:location-functions-polytr}
Due to the lifting of the left-to-right invariant of the x-monotone polylines, the functions \code{locate()} and \code{locate\_side()} had to be corrected.
During the correction a mistake in the original implementation was found.
Consider the following simple example.
Set \(p_0 = (-1,0), p_1 = (0,0)\) and \(p_2 = (1,0)\) and let \(c\) be the \(x\)-monotone polyline which connects them.
Next, let \(q = (0,1)\) be the query point.
\begin{center}
\begin{tikzpicture}
\coordinate (p0) at (-1,0);
\coordinate (p1) at (0,0);
\coordinate(p2) at (1,0);
\coordinate(q) at (0,1);
\draw (p0) --node[above]{$e_0$} (p1) --node[above]{$e_1$} (p2);
\foreach \i in {0,1,2}
\fill (p\i)node[below]{$p_{\i}$} circle (2pt);
\fill (q)node[right]{$q$} circle (2pt);
\draw[dashed] (p1) -- (q);
\end{tikzpicture}
\end{center}
In the original implementation \code{_locate(seg_tr,c,q)} would return the index \(i=0\).
But in this case neither of the tests
\begin{pyglist}
if (equal(segment_traits_2()->construct_min_vertex_2_object()(cv[i]), q))
if (equal(segment_traits_2()->construct_max_vertex_2_object()(cv[i]), q))
\end{pyglist}
\noindent would yield \emph{TRUE} and thus \code{_locate_side(seg_tr,c,q,ture)} would return \(i=0\), while it \emph{should} yield \(i=1\).
\subsection{Changes Derived from \poly}
\label{sec:changes-derived-from-polytr}
As a result of the changes in \poly and \xpoly (cf. \cref{sec:implementation-poly}), updates and modifications are needed also in \polytr.
In particular the lifting of the left-to-right direction invariant of the \(x\)-monotone polylines forced changes in almost \emph{all} functors of \polytr.
Most significant functors which were influenced by this change were:
\begin{itemize}
\item \functor{Make_x_monotone_2}
\item \functor{Intersect_2}
\item \functor{Merge_2}
\item \functor{Split_2}
\end{itemize}
\section{Testing the Code}
\label{sec:testing-code}
The original tests which were carried out were limited and naturally did not consider the cases of \(x\)-monotone polylines which are oriented right-to-left.
Thus, in order to verify that the upgraded implementation is correct, we extended the tests so they cover the cases of inverse \(x\)-monotone polylines.
\paragraph{\functor{Intersect_2}:}
\label{sec:testing-intersect_2}
\cref{fig:test-cases-of-intersect_2} illustrates all the \xpoly's that we considered in out testings.
Note that we considered all the possible pairs of \xpoly's that arise from the family of \(x\)-monotone polylines that we consider in the image.
\begin{figure}
\centering
\includegraphics[width=\linewidth]{./figures/intersect}
\caption{The \xpoly's used in testing \functor{Intersect_2}}
\label{fig:test-cases-of-intersect_2}
\end{figure}
\section{Benchmark}
\label{sec:benchmark}
Once we finished testing the code we benchmarked the code in order to verify that the changes did not impair the performances.
Indeed, the usage of advanced coding resulted in an improvement of \(4.8\%\) in average.
For the benchmark we used the code which can be found in \file{bench_random_arr_polylines.cpp} in \file{Arrangement_on_surface_2/benchmark/Arrangement_on_surface_2}.
Note that this code uses the \emph{deprecated} construction of polylines -- we did it in order to run the same benchmark both on the original implementation and on our improvement.
\cref{tab:benchmark-results} in \cref{sec:summ-benchm-tests} summarizes the results of the benchmarks.
\section{Future Work}
\label{sec:future-work}
While working on this project we discovered several issues which have to be addressed.
These issues vary from purely technicalities that have to be addressed to issues which involve design decisions that have to be taken.
\begin{itemize}
\item Re-implement \code{locate()} so it will return a \emph{pointer} rather then an index to the containing segment.
\item Fix \functor{Make_x_monotone_2} so it will not depend on the input's order.
Consider the following example.
Let \(T\) be the triangle defined by the vertices \(p_1 = (0,2), p_2 = (-1,-1)\) and \(p_3 = (1,-1)\).
From a strictly mathematical point of view the \(T\) can be treated as a polyline, and in turn the induced arrangement would consist of \emph{one} vertex, one edge (the triangle \(T\) itself) and \emph{two faces}.
Since the implementation of the arrangement package depends on the notion of \(x\)-monotone curves, we cannot avoid having \emph{two} vertices and \emph{two} edges in the resulting arrangement.
However, depending on the order in which the points are given the current implementation can yield different results.
The triangle defined by \(\overline{p_2 p_1 p_3 p_2}\) yields \((2,2,2)\) as its \(f\)-vector, whereas \(\overline{p_1 p_2 p_3 p_1}\) yields the \(f\)-vector \((3,3,2)\).
Note that the number of face is correct, but the other elements of the vector are not stable.
\item Accessing the segments of a polyline.
Currently accessing a segment of either a \poly or \xpoly is done using the \code{operator[]}.
Replace this accessing method with iterators/handles.
\item The concept definition of the functor \functor{AreMergeable_2} states when two \(x\)-monotone polylines are mergable:
\begin{quote}
\emph{``\emph{xc1} and \emph{xc2} are mergeable if their underlying curves are identical, they share a common endpoint, and they do not bend to form a non- x-monotone curve.''}
\end{quote}
This definition is rather restrictive and rule out curves that intuitively speaking should be mergeable.
For example, the case of overlapping curves is \emph{not} considered mergeable.
In turn, the current implementation of \functor{Merge_2} deals merely with concatenation of \xpoly's.
We recommend to revolve the definitions of the concepts \functor{AreMergeable_2} and \functor{Merge_2}.
A priori, allowing the merging of overlapping curves can save possibly redundant computations.
\item Intersection at a common vertex.
If two \xpoly's have a proper intersection at a common vertex then the existing implementation returns a multiplicity \(0\).
Consider, for example, the following
\begin{center}
\begin{tikzpicture}[scale=0.5]
\draw[blue] (0,2) node [shape=circle,fill,inner sep = 1pt]{} -- (1,1) -- (2,2) node [shape=circle,fill,inner sep = 1pt]{};
\draw[red] (0,0) node [shape=circle,fill,inner sep = 1pt]{} -- (1,1) node [shape=circle,fill=black,inner sep = 1pt]{} -- (2,0) node [shape=circle,fill,inner sep = 1pt]{};
\pgftransformxshift{4cm}
\draw[blue] (0,2) node [shape=circle,fill,inner sep = 1pt]{} -- (1,1) -- (2,0) node [shape=circle,fill,inner sep = 1pt]{};
\draw[red] (0,0) node [shape=circle,fill,inner sep = 1pt]{} -- (1,1) node [shape=circle,fill=black,inner sep = 1pt]{} -- (2,2) node [shape=circle,fill,inner sep = 1pt]{};
\end{tikzpicture}
\end{center}
The current implementation will yield the right intersection point and will assign multiplicity \(0\) for both cases, although it is natural to expect that the multiplicity will be \(1\).
See for reference, the pairs \(\{12,34\}\), \(\{15,35\}\) and others in the test cases of \functor{Intersect_2} \cref{fig:test-cases-of-intersect_2}.
\end{itemize}
\appendix
\section{Summary of benchmark tests}
\label{sec:summ-benchm-tests}
\begin{landscape}
\begin{table}
\centering
\begin{tabular}{rrrrrrrrr}
\hline
Seed & N & V & E & F & Timer (B) & Timer (M) & \% & Mean \% \\
\hline
\hline
1368346973 & 10 & 10 & 12 & 4 & 0.000768 & 0.000712 & -7.8651685 & \\
\hline
1368346990 & 10 & 7 & 9 & 4 & 0.000673 & 0.000608 & -10.690789 & \\
\hline
1368347002 & 10 & 10 & 13 & 5 & 0.000716 & 0.000674 & -6.2314540 & -8.2624705 \\
\hline
1368347036 & 50 & 326 & 615 & 291 & 0.017041 & 0.017389 & 2.0012652 & \\
\hline
1368347050 & 50 & 259 & 485 & 228 & 0.013991 & 0.01423 & 1.6795502 & \\
\hline
1368347062 & 50 & 254 & 471 & 219 & 0.013594 & 0.014035 & 3.1421446 & 2.27432 \\
\hline
1368347141 & 500 & 29357 & 58378 & 29023 & 1.50945 & 1.65587 & 8.8424816 & \\
\hline
1368347165 & 500 & 26395 & 52464 & 26071 & 1.36537 & 1.44331 & 5.4000873 & \\
\hline
1368347184 & 500 & 27592 & 54847 & 27257 & 1.4248 & 1.50637 & 5.4150043 & 6.5525244 \\
\hline
1368347214 & 1000 & 117252 & 233848 & 116598 & 6.13624 & 6.39283 & 4.0137154 & \\
\hline
1368347267 & 1000 & 115255 & 229844 & 114591 & 6.05129 & 6.32789 & 4.3711253 & \\
\hline
1368347320 & 1000 & 122911 & 245155 & 122246 & 6.41939 & 6.78416 & 5.3767895 & 4.5872101 \\
\hline
1371453603 & 2000 & 453785 & 906218 & 452435 & 24.2019 & 25.3598 & 4.5658877 & \\
\hline
1371453661 & 2000 & 472734 & 944122 & 471390 & 25.1665 & 26.2028 & 3.9549208 & \\
\hline
1371453708 & 2000 & 450377 & 899397 & 449022 & 23.8502 & 24.9693 & 4.4819038 & 4.3342374 \\
\hline
1371453752 & 2500 & 710089 & 1418556 & 708469 & 37.8684 & 39.9537 & 5.2192913 & \\
\hline
1371453814 & 2500 & 739811 & 1477940 & 738131 & 39.4883 & 41.7421 & 5.3993450 & \\
\hline
1371453926 & 2500 & 730482 & 1459272 & 728792 & 40.0593 & 40.8858 & 2.0214842 & 4.2133735 \\
\hline
1371453996 & 3000 & 1041705 & 2081422 & 1039719 & 56.5583 & 60.2639 & 6.1489548 & \\
\hline
1371454074 & 3000 & 1024104 & 2046202 & 1022100 & 55.2771 & 61.2115 & 9.6949103 & \\
\hline
1371454144 & 3000 & 1011434 & 2020912 & 1009480 & 54.5034 & 57.0535 & 4.4696644 & 6.7711765 \\
\hline
\end{tabular}
\caption{Benchmark results}
\label{tab:benchmark-results}
\end{table}
\end{landscape}
\end{document}
%%% Local Variables:
%%% mode: latex
%%% TeX-master: t
%%% End:

50
BGL/include/CGAL/boost/graph/named_function_params.h
View File

@ -68,6 +68,8 @@ namespace CGAL {
enum get_cost_policy_params_t { get_cost_policy_params } ;
enum get_placement_policy_t { get_placement_policy } ;
enum get_placement_policy_params_t { get_placement_policy_params } ;
enum edge_is_constrained_t { edge_is_constrained } ;
enum edge_is_constrained_params_t { edge_is_constrained_params } ;
#if BOOST_VERSION >= 105100
template <typename T, typename Tag, typename Base = boost::no_property>
@ -166,6 +168,22 @@ namespace CGAL {
typedef cgal_bgl_named_params<GetPlacementParams, get_placement_policy_params_t, self> Params;
return Params(p, *this);
}
template <typename EdgeIsConstrained>
cgal_bgl_named_params<EdgeIsConstrained, edge_is_constrained_t, self>
edge_is_constrained_map(const EdgeIsConstrained& em) const
{
typedef cgal_bgl_named_params<EdgeIsConstrained, edge_is_constrained_t, self> Params;
return Params(em, *this);
}
template <typename EdgeIsConstrainedParams>
cgal_bgl_named_params<EdgeIsConstrainedParams, edge_is_constrained_params_t, self>
edge_is_constrained_map_params(const EdgeIsConstrainedParams& em) const
{
typedef cgal_bgl_named_params<EdgeIsConstrainedParams, edge_is_constrained_params_t, self> Params;
return Params(em, *this);
}
};
#else
template <typename T, typename Tag, typename Base = boost::no_property>
@ -270,6 +288,22 @@ namespace CGAL {
typedef cgal_bgl_named_params<GetPlacementParams, get_placement_policy_params_t, self> Params;
return Params(p, *this);
}
template <typename EdgeIsConstrained>
cgal_bgl_named_params<EdgeIsConstrained, edge_is_constrained_t, self>
edge_is_constrained_map(const EdgeIsConstrained& em) const
{
typedef cgal_bgl_named_params<EdgeIsConstrained, edge_is_constrained_t, self> Params;
return Params(em, *this);
}
template <typename EdgeIsConstrainedParams>
cgal_bgl_named_params<EdgeIsConstrainedParams, edge_is_constrained_params_t, self>
edge_is_constrained_map_params(const EdgeIsConstrainedParams& em) const
{
typedef cgal_bgl_named_params<EdgeIsConstrainedParams, edge_is_constrained_params_t, self> Params;
return Params(em, *this);
}
};
template <class Tag1, class Tag2, class T1, class Base>
@ -373,6 +407,22 @@ namespace CGAL {
typedef cgal_bgl_named_params<GetPlacementParams, get_placement_policy_params_t> Params;
return Params(p);
}
template <typename EdgeIsConstrained>
cgal_bgl_named_params<EdgeIsConstrained, edge_is_constrained_t>
edge_is_constrained_map(const EdgeIsConstrained& em)
{
typedef cgal_bgl_named_params<EdgeIsConstrained, edge_is_constrained_t> Params;
return Params(em);
}
template <typename EdgeIsConstrainedParams>
cgal_bgl_named_params<EdgeIsConstrainedParams, edge_is_constrained_params_t>
edge_is_constrained_map_params(const EdgeIsConstrainedParams& em)
{
typedef cgal_bgl_named_params<EdgeIsConstrainedParams, edge_is_constrained_params_t> Params;
return Params(em);
}
} //namespace CGAL
#if BOOST_VERSION >= 105100

79
Documentation/CMakeLists.txt
View File

@ -37,7 +37,7 @@ function(configure_doxygen_package CGAL_PACKAGE_NAME)
file(APPEND ${CGAL_DOC_PACKAGE_DEFAULTS} "IMAGE_PATH = ${CGAL_PACKAGE_DIR}/doc/${CGAL_PACKAGE_NAME}/fig\n")
file(APPEND ${CGAL_DOC_PACKAGE_DEFAULTS} "EXAMPLE_PATH = ${CGAL_PACKAGE_DIR}/examples\n")
file(APPEND ${CGAL_DOC_PACKAGE_DEFAULTS} "GENERATE_TAGFILE = ${CGAL_DOC_TAG_DIR}/${CGAL_PACKAGE_NAME}.tag\n")
file(APPEND ${CGAL_DOC_PACKAGE_DEFAULTS} "GENERATE_TAGFILE = ${CGAL_DOC_TAG_GEN_DIR}/${CGAL_PACKAGE_NAME}.tag\n")
file(APPEND ${CGAL_DOC_PACKAGE_DEFAULTS} "STRIP_FROM_PATH = ${CGAL_PACKAGE_DIR}/doc/${CGAL_PACKAGE_NAME}/\n")
file(APPEND ${CGAL_DOC_PACKAGE_DEFAULTS} "STRIP_FROM_PATH += ${CGAL_PACKAGE_DIR}/include/\n")
file(APPEND ${CGAL_DOC_PACKAGE_DEFAULTS} "STRIP_FROM_INC_PATH = ${CGAL_PACKAGE_DIR}/doc/${CGAL_PACKAGE_NAME}/\n")
@ -61,11 +61,34 @@ function(configure_doxygen_package CGAL_PACKAGE_NAME)
${CGAL_DOC_DXY_DIR}/${CGAL_PACKAGE_NAME}.dxy)
# TODO we also want to run html_post_process per package as a custom_command with POST_BUILD
add_custom_target(${CGAL_PACKAGE_NAME}_doc
# target that build the doc and put the tag file in the generation directory CGAL_DOC_TAG_GEN_DIR
add_custom_target(${CGAL_PACKAGE_NAME}_internal_doxygen_run
${DOXYGEN_EXECUTABLE} ${CGAL_DOC_DXY_DIR}/${CGAL_PACKAGE_NAME}.dxy)
set_target_properties(${CGAL_PACKAGE_NAME}_doc PROPERTIES FOLDER Documentation/Packages)
set_target_properties(${CGAL_PACKAGE_NAME}_internal_doxygen_run PROPERTIES FOLDER Documentation/Packages)
#target moving the tag file into the read directory CGAL_DOC_TAG_DIR
if ( "${CGAL_PACKAGE_NAME}" STREQUAL "Documentation" )
set(CGAL_PACKAGE_TAGFILE "Manual.tag")
else()
set(CGAL_PACKAGE_TAGFILE "${CGAL_PACKAGE_NAME}.tag")
endif()
add_custom_target(${CGAL_PACKAGE_NAME}_copy_doc_tags
${CMAKE_COMMAND} -E copy
"${CGAL_DOC_TAG_GEN_DIR}/${CGAL_PACKAGE_TAGFILE}"
"${CGAL_DOC_TAG_DIR}/${CGAL_PACKAGE_TAGFILE}"
)
#add the doc target doing both the doc generation and then the tag file copy
add_custom_target(${CGAL_PACKAGE_NAME}_doc
${DOXYGEN_EXECUTABLE} ${CGAL_DOC_DXY_DIR}/${CGAL_PACKAGE_NAME}.dxy
COMMAND
${CMAKE_COMMAND} -E copy
"${CGAL_DOC_TAG_GEN_DIR}/${CGAL_PACKAGE_TAGFILE}"
"${CGAL_DOC_TAG_DIR}/${CGAL_PACKAGE_TAGFILE}"
)
# ${depend}_doc)
# don't do this for now
# foreach(depend ${DEPENDENCIES})
# add_dependencies(${CGAL_PACKAGE_NAME}_doc
@ -98,6 +121,10 @@ if(DOXYGEN_FOUND)
file(MAKE_DIRECTORY "${CGAL_DOC_LOG_DIR}")
endif()
#we use two directories for the generation/reading of tag files to prevent issues
#if the targets are built in parallel
set(CGAL_DOC_TAG_GEN_DIR "${CMAKE_BINARY_DIR}/doc_gen_tags")
file(MAKE_DIRECTORY "${CGAL_DOC_TAG_GEN_DIR}")
set(CGAL_DOC_TAG_DIR "${CMAKE_BINARY_DIR}/doc_tags")
file(MAKE_DIRECTORY "${CGAL_DOC_TAG_DIR}")
set(CGAL_DOC_DXY_DIR "${CMAKE_BINARY_DIR}/doc_dxy")
@ -115,7 +142,7 @@ if(DOXYGEN_FOUND)
string(TIMESTAMP CGAL_BUILD_YEAR2 "%y")
string(TIMESTAMP CGAL_BUILD_MONTH "%m")
else()
MESSAGE(STATUS "You're using an old version of CGAL, date in bibtex files will be incorrect")
MESSAGE(WARNING "You're using an old version of CMake, date in bibtex files will be incorrect")
set(CGAL_BUILD_YEAR4 "2000")
set(CGAL_BUILD_YEAR2 "00")
set(CGAL_BUILD_MONTH "1")
@ -133,14 +160,27 @@ if(DOXYGEN_FOUND)
find_program(BIBTEX2HTML_EXECUTABLE bibtex2html DOC "Path to bibtex2html")
find_program(SH_EXECUTABLE sh DOC "Path to sh")
if (BIBTEX2HTML_EXECUTABLE AND SH_EXECUTABLE)
set(ENV{openout_any} "a") # may be needed with TexLive
execute_process(COMMAND ${SH_EXECUTABLE}
${CMAKE_CURRENT_SOURCE_DIR}/scripts/makebiblio
${CMAKE_BINARY_DIR}/how_to_cite_cgal.bib
${BIBTEX2HTML_EXECUTABLE}
OUTPUT_QUIET
ERROR_QUIET) #bibtex2html also prints info in stderr
OUTPUT_VARIABLE makebiblio_OUTPUT
ERROR_VARIABLE makebiblio_ERROR
RESULT_VARIABLE makebiblio_RESULT) #bibtex2html also prints info in stderr
if(makebiblio_RESULT GREATER 0)
message(WARNING "
= makebiblio returned the error number ${makebiblio_RESULT}
== Its standard output was:
${makebiblio_OUTPUT}
== Its error output was:
${makebiblio_ERROR}
"
)
endif()
else()
MESSAGE(STATUS "bibtex2html or sh missing, using default how_to_cite files")
MESSAGE(WARNING "bibtex2html or sh missing, using default how_to_cite files")
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/how_to_cite.html.default ${CMAKE_BINARY_DIR}/how_to_cite.html COPYONLY)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/resources/how_to_cite_cgal.txt.default ${CMAKE_BINARY_DIR}/how_to_cite_cgal.txt COPYONLY)
endif()
@ -168,6 +208,8 @@ if(DOXYGEN_FOUND)
# Add a custom target "doc"
add_custom_target(doc)
add_custom_target(doc_pre)
add_custom_target(doc_post)
# do the main package manually, it isn't part of ${CGAL_CONFIGURED_PACKAGES_NAMES}
configure_doxygen_package("Documentation")
@ -176,29 +218,40 @@ if(DOXYGEN_FOUND)
# hard-code that doc depends on all packages
file(STRINGS ${CMAKE_SOURCE_DIR}/Documentation/doc/Documentation/dependencies DEPENDENCIES)
foreach(depend ${DEPENDENCIES})
add_dependencies(doc ${depend}_doc)
add_dependencies(doc_pre ${depend}_internal_doxygen_run)
add_dependencies(doc_post ${depend}_copy_doc_tags)
add_dependencies(${depend}_copy_doc_tags doc_pre)
endforeach()
add_dependencies(doc Documentation_doc)
add_dependencies(doc_pre Documentation_internal_doxygen_run)
add_dependencies(doc_post Documentation_copy_doc_tags)
add_dependencies(Documentation_copy_doc_tags doc_pre)
#total level doc dependencies
add_dependencies(doc doc_post)
if(PYTHONINTERP_FOUND)
add_custom_target(doc_with_postprocessing
${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/html_output_post_processing.py --output ${CGAL_DOC_OUTPUT_DIR} --resources ${CMAKE_CURRENT_SOURCE_DIR}/resources
DEPENDS doc)
)
add_dependencies(doc_with_postprocessing doc)
if(CGAL_DOC_CREATE_LOGS)
add_custom_target(Documentation_test
${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testsuite.py --output-dir ${CGAL_DOC_OUTPUT_DIR} --doc-log-dir ${CGAL_DOC_LOG_DIR}
DEPENDS doc)
)
add_dependencies(Documentation_test doc)
add_custom_target(Documentation_test_publish
${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testsuite.py --output-dir ${CGAL_DOC_OUTPUT_DIR} --doc-log-dir ${CGAL_DOC_LOG_DIR} --publish ${CGAL_DOC_PUBLISH_DIR} --do-copy-results
DEPENDS doc)
)
add_dependencies(Documentation_test_publish doc)
set(CGAL_DOC_VERSION_H "/tmp/version.h" CACHE PATH "Path to CGAL/version.h")
add_custom_target(doc_and_publish_testsuite
${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/testsuite.py --output-dir ${CGAL_DOC_OUTPUT_DIR} --doc-log-dir ${CGAL_DOC_LOG_DIR} --publish ${CGAL_DOC_PUBLISH_DIR} --do-copy-results --cgal-version ${CGAL_DOC_VERSION_H} --version-to-keep 10
DEPENDS doc_with_postprocessing)
)
add_dependencies(doc_and_publish_testsuite doc_with_postprocessing)
endif()
endif()

2
Documentation/doc/Documentation/Doxyfile.in
View File

@ -9,7 +9,7 @@ INPUT = ${CMAKE_SOURCE_DIR}/Documentation/doc/Documentation \
HTML_HEADER = ${CGAL_DOC_HEADER}
LAYOUT_FILE = ${CMAKE_SOURCE_DIR}/Documentation/DoxygenLayout.xml
GENERATE_TAGFILE = ${CGAL_DOC_TAG_DIR}/Manual.tag
GENERATE_TAGFILE = ${CGAL_DOC_TAG_GEN_DIR}/Manual.tag
EXAMPLE_PATH = ${CMAKE_SOURCE_DIR}/Convex_hull_2/examples
FILTER_PATTERNS = *.txt=${CMAKE_BINARY_DIR}/pkglist_filter

2
Documentation/html_output_post_processing.py
View File

@ -46,6 +46,8 @@ def conceptify(d):
# fix the title
title = d(".title")
title.html(re.sub("((Class)|(Struct))( Template)? Reference", "Concept Reference", title.html()))
title = d("title")
title.html(re.sub("((Class)|(Struct))( Template)? Reference", "Concept Reference", title.html()))
# remove the include
include_statement = d(".contents").children().eq(0)
# should check that this is really the div we think it is

4
Documentation/scripts/makebiblio
View File

@ -1,6 +1,8 @@
#!/bin/sh
$2 -nodoc $1
set -e
$2 -q -nodoc $1
mv ${1%.bib}.html tmp_array_bib.html
mv ${1%.bib}_bib.html how_to_cite.html

4
GraphicsView/demo/Periodic_2_triangulation_2/CMakeLists.txt
View File

@ -36,7 +36,7 @@ qt4_wrap_ui( DT_UI_FILES Periodic_2_triangulation_2.ui )
qt4_add_resources ( DT_RESOURCE_FILES ./Periodic_2_triangulation_2.qrc )
# use the Qt MOC preprocessor on classes that derives from QObject
qt4_generate_moc( Periodic_2_triangulation_2.cpp Periodic_2_triangulation_2.moc )
qt4_generate_moc( Periodic_2_Delaunay_triangulation_2.cpp Periodic_2_triangulation_2.moc )
# find header files for projects that can show them
file(GLOB headers "*.h")
@ -47,7 +47,7 @@ SOURCE_GROUP("QT" FILES ${QT_headers})
# The executable itself.
add_executable ( Periodic_2_Delaunay_triangulation_2
Periodic_2_triangulation_2.cpp
Periodic_2_Delaunay_triangulation_2.cpp
Periodic_2_triangulation_2.moc
${DT_UI_FILES} ${DT_RESOURCE_FILES}
${headers} ${QT_headers} ${P2T2_headers})

5
GraphicsView/demo/Periodic_2_triangulation_2/Periodic_2_triangulation_2.cpp → GraphicsView/demo/Periodic_2_triangulation_2/Periodic_2_Delaunay_triangulation_2.cpp
View File

@ -291,7 +291,8 @@ MainWindow::on_actionClear_triggered()
void
MainWindow::on_actionInsertRandomPoints_triggered()
{
CGAL::Random_points_in_iso_rectangle_2<Point_2> pg(triang.domain().min(), triang.domain().max());
CGAL::Random_points_in_iso_rectangle_2<Point_2> pg((triang.domain().min)(),
(triang.domain().max)());
bool ok = false;
const int number_of_points =
QInputDialog::getInteger(this,
@ -299,7 +300,7 @@ MainWindow::on_actionInsertRandomPoints_triggered()
tr("Enter number of random points"),
250,
0,
std::numeric_limits<int>::max(),
(std::numeric_limits<int>::max)(),
1,
&ok);

5
GraphicsView/demo/Periodic_2_triangulation_2/include/CGAL/Qt/PeriodicTriangulationGraphicsItem.h
View File

@ -214,6 +214,7 @@ namespace CGAL {
itype = T::UNIQUE_COVER_DOMAIN;
break;
case NONE:
default:
assert(false);
itype = T::STORED;
break;
@ -344,7 +345,9 @@ namespace CGAL {
typename T::Covering_sheets sheets = t->number_of_sheets();
for (int x=0; x<sheets[0]; ++x) {
for (int y=0; y<sheets[1]; ++y) {
painter->drawRect(domain.xmin() + x*dx, domain.ymin() + y*dy, dx, dy);
painter->drawRect((int)(domain.xmin() + x*dx),
(int)(domain.ymin() + y*dy),
(int)dx, (int)dy);
}
}
m_painter = painter;

2
GraphicsView/demo/Triangulation_2/Constrained_Delaunay_triangulation_2.cpp
View File

@ -535,6 +535,8 @@ MainWindow::loadEdgConstraints(QString fileName)
tim.stop();
statusBar()->showMessage(QString("Insertion took %1 seconds").arg(tim.time()), 2000);
initializeID(cdt);
discoverComponents(cdt);
// default cursor
QApplication::restoreOverrideCursor();
emit(changed());

3
GraphicsView/demo/resources/CGAL.qrc
View File

@ -3,7 +3,8 @@
<file>about_CGAL.html</file>
</qresource>
<qresource prefix="/cgal/logos">
<file alias="CGAL.gif" >cgal_large_FAF8E8.gif</file>
<file alias="CGAL.gif" >cgal_logo_ipe_2013.png</file>
<file alias="CGAL.png" >cgal_logo_ipe_2013.png</file>
<file alias="cgal_icon" >cgal_logo.xpm</file>
</qresource>
</RCC>

2
GraphicsView/demo/resources/about_CGAL.html
View File

@ -1,6 +1,6 @@
<html>
<body>
<p><img src=":/cgal/logos/CGAL.gif"></p>
<p><img src=":/cgal/logos/CGAL.png"></p>
<h2>Computational Geometry Algorithms Library<!--CGAL_VERSION--></h2>
<p>CGAL provides efficient and reliable geometric algorithms in the form of a C++ library.</p>
<p>For more information visit <a href="http://www.cgal.org/">www.cgal.org</a></p>

BIN
GraphicsView/demo/resources/cgal_large_FAF8E8.gif
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 18 KiB

BIN
GraphicsView/demo/resources/cgal_logo_ipe_2013.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 27 KiB

25
Installation/CHANGES
View File

@ -2,6 +2,15 @@
-------------------------------- Release 4.4 --------------------------------
* Installation
- Additional supported platforms:
- The Apple Clang compiler version 5.0 is now supported on
OS X Mavericks.
* Triangulated Surface Mesh Segmentation (new package)
- This package implements the segmentation of triangulated surface meshes
@ -89,9 +98,19 @@
circumcenters and sliver criterion values only when needed.
* STL Extensions for CGAL
* Triangulated Surface Mesh Simplification
- Add the function CGAL::make_sorted_pair.
- Fix a bug in the way edges can be marked as non-removable by adding a
named-parameter edge_is_constrained_map to the function edge_collapse
* dD Spatial Searching
- Fix a documentation bug: The property map passed as template parameter to
the classes Search_traits_adapter and Distance_adapter must be a lvalue
property map. To avoid incorrect usage, a static assertion has been added
in the CGAL code to prevent the user from instantiating these classes with
an incorrect property map type.
* CGAL ipelets
@ -100,7 +119,7 @@
- New ipelet for pencils of circles
- New ipelet for hyperbolic geometry in Poincare model
- New ipelet for hyperbolic geometry in Poincaré model
- The generator ipelet now generates point in a selected zone

31
Installation/changes.html
View File

@ -111,6 +111,19 @@ and <code>src/</code> directories).
<h2 id="release4.4">Release 4.4 </h2>
<div>
<!-- <p> Release date: October 2013 </p> -->
<h3>Installation</h3>
<ul>
<li>Additional supported platforms:
<ul>
<li>The Apple Clang compiler version 5.0 is now supported on
OS X Mavericks.</li>
<!--
<li>The Microsoft Windows Visual C++ compiler 2013 (VC12) is now
supported.</li>
-->
</ul>
</li>
</ul>
<h3>Triangulated Surface Mesh Segmentation (new package)</h3>
<ul>
<li> This package implements the segmentation of triangulated surface meshes
@ -216,20 +229,30 @@ and <code>src/</code> directories).
</li>
</ul>
<h3>STL Extensions for CGAL</h3>
<h3>Triangulated Surface Mesh Simplification</h3>
<ul>
<li> Add the function <code>CGAL::make_sorted_pair</code>.</li>
<li>Fix a bug in the way edges can be marked as non-removable by adding
a named-parameter <code>edge_is_constrained_map</code> to the function
<code>edge_collapse</code></li>
</ul>
<h3>dD Spatial Searching</h3>
<ul>
<li>Fix a documentation bug: The property map passed as template parameter to the classes
<code>Search_traits_adapter</code> and <code>Distance_adapter</code> must be a
lvalue property map. To avoid incorrect usage, a static assertion has been added
in the CGAL code to prevent the user from instantiating these classes with an
incorrect property map type.</li>
</ul>
<h3>CGAL ipelets</h3>
<ul>
<li> Better description of the demo ipelets in the user manual </li>
<li> New ipelet for pencils of circles</li>
<li> New ipelet for hyperbolic geometry in Poincare model</li>
<li> New ipelet for hyperbolic geometry in Poincaré model</li>
<li> The generator ipelet now generates point in a selected zone</li>
<li> Hilbert sort ipelet implements two policies</li>
</ul>
</div>
<h2 id="release4.3">Release 4.3 </h2>

23
Installation/doc_html/Manual/index.html Normal file
View File

@ -0,0 +1,23 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en-US">
<head>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<link rel="shortcut icon" href="../cgal.ico">
<TITLE>CGAL - Computational Geometry Algorithms Library</TITLE>
<LINK REL=stylesheet TYPE="text/css" HREF="../cgal.css">
</head>
<body>
<h2>CGAL Manual</h2>
<p>
You can download the manual as <em>tarball</em>
from the <a href="https://gforge.inria.fr/frs/?group_id=52">
CGAL Download Page</a>, or with the <em>Windows Installer</em>.
</p>
</body>
</html>

23
Installation/doc_html/Manual/packages.html Normal file
View File

@ -0,0 +1,23 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en-US">
<head>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<link rel="shortcut icon" href="../cgal.ico">
<TITLE>CGAL - Computational Geometry Algorithms Library</TITLE>
<LINK REL=stylesheet TYPE="text/css" HREF="../cgal.css">
</head>
<body>
<h2>CGAL Manual</h2>
<p>
You can download the manual as <em>tarball</em>
from the <a href="https://gforge.inria.fr/frs/?group_id=52">
CGAL Download Page</a>, or with the <em>Windows Installer</em>.
</p>
</body>
</html>

58
Installation/doc_html/cgal.css Normal file
View File

@ -0,0 +1,58 @@
html, body {
margin:0;
background-color: #FAF8E8;
font-family: arial,sans-serif;
color:black;
}
li { font-size:100%;}
p { text-align:justify; font-size:100%; margin: 5pt;}
img { border-width: 0pt; }
dl,p,h1,h2,h3,h4,ul,ol,li,div,td,th,address,blockquote,nobr,b
{ font-family:Arial,sans-serif; }
td { text-align:justify;}
h1 { font-size:180%; margin-left: 5pt;}
h2 { font-size:160%; margin-left: 5pt;}
h3 { font-size:100%; margin-left: 5pt;}
h4 { font-size:90%; margin-left: 5pt;}
pre { font-family:Courier New,Courier; font-size:100%; }
tt { font-family:Courier New,Courier; font-size:100%; }
/* a:link { color:#050060; text-decoration:none; } */
/* a:visited { color:#590059; text-decoration:none; } */
/* a:active { color:#000000; text-decoration:none; } */
a:link { text-decoration:none; }
a:visited { color: #5000CC; text-decoration:none; }
a:active { color: #00A080; text-decoration:none; }
.contact { font-family:arial,sans-serif; font-size:100%}
.news {font-size:90%;}
td.menu { background-color: #C0C0D0; white-space:nowrap }
/* We are forced to duplicate definitions because IE does not support ">" */
div.menu { font-size:100%; /* margin-left: -30pt; */ /* margin-top: 10pt; margin-bottom: 3pt */ }
div.menu > h4 { font-size:100%; /* margin-left: 3pt; */ margin-top: 10pt; margin-bottom: 3pt; }
h4.menu { font-size:100%; /* margin-left: 3pt; */ margin-top: 10pt; margin-bottom: 3pt; }
div.menu > p { font-size:100%; margin-left: 10pt; margin-top: 0pt; margin-bottom:0pt; /*; margin-right:5pt */ }
p.menu { font-size:100%; margin-left: 10pt; margin-top: 0pt; margin-bottom:0pt; /*; margin-right:5pt */ }
img.menu { margin-top: 0pt; margin-bottom:0pt }
em.menu { font-style: normal; font-family:Arial,sans-serif; font-size:90%; }
.subtitle { font-family: cursive; font-size: 120% }

BIN
Installation/doc_html/cgal.ico Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 894 B

BIN
Installation/doc_html/images/cgal_2013_grey.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 28 KiB

58
Installation/doc_html/index.html Normal file
View File

@ -0,0 +1,58 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html lang="en-US">
<head>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<link rel="shortcut icon" href="cgal.ico">
<TITLE>CGAL - Computational Geometry Algorithms Library</TITLE>
<LINK REL=stylesheet TYPE="text/css" HREF="cgal.css">
</head>
<body>
<CENTER>
<IMG SRC="images/cgal_2013_grey.png" ALT="CGAL">
</CENTER>
<CENTER>
<span class=subtitle>Computational Geometry Algorithms Library</span>
</CENTER>
<p>
The goal of the CGAL Open Source Project is to provide
<em>easy access to efficient and reliable geometric algorithms</em>
in the form of a C++ library.
</p>
<h3>Manuals</h3>
<ul>
<li><a href ="Manual/index.html">CGAL Manual - Table of Contents</a>
<li><a href ="Manual/packages.html">CGAL Manual - Package Overview</a>
<li>You can also access the CGAL Online Manual from the
<a href="http://www.cgal.org/">CGAL website</a>.
</ul>
<h3>Further Links</h3>
<ul>
<li><a href ="http://www.cgal.org/">CGAL Homepage</a>
<li><a href ="http://www.cgal.org/FAQ.html#installation">FAQ concerning Installation</a>
<li><a href ="http://www.boost.org/doc/">Boost Documentation</a>
<li><a href ="http://en.cppreference.com/w/">STL Reference</a>
</ul>
<h3>License</h3>
<p>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
<a href="http://www.geometryfactory.com">GeometryFactory</a>.
For more details see the <a href="http://www.cgal.org/license.html">License</a> page.
<p>
</body>
</html>

10
Installation/include/CGAL/config.h
View File

@ -69,6 +69,14 @@
#include <CGAL/export/CGAL.h>
//----------------------------------------------------------------------//
// Use an implementation of fabs with sse2 on Windows
//----------------------------------------------------------------------//
#if (_M_IX86_FP >= 2) || defined(_M_X64)
#define CGAL_USE_SSE2_FABS
#endif
//----------------------------------------------------------------------//
// Detect features at compile-time. Some macros have only been
// introduced as of Boost 1.40. In that case, we simply say that the
@ -118,7 +126,7 @@
#if !defined(__GNUC__) || defined(__INTEL_COMPILER)
#define CGAL_CFG_NO_STATEMENT_EXPRESSIONS 1
#endif
#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) || (BOOST_VERSION < 105100)
#if defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) || (BOOST_VERSION < 105100) || _MSC_VER==1800
#define CGAL_CFG_NO_CPP0X_UNIFIED_INITIALIZATION_SYNTAX
#endif
#if __cplusplus < 201103L && !(_MSC_VER >= 1600)

5
Inventor/include/CGAL/IO/Inventor_ostream.h
View File

@ -53,9 +53,10 @@ public:
|| defined BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
typedef const void* Const_void_ptr;
operator Const_void_ptr () const {
if ( m_os)
return *m_os;
if ( m_os->fail() )
return 0;
else
return static_cast<Const_void_ptr>(m_os);
}
#else
explicit operator bool ()

8
Inventor/include/CGAL/IO/VRML_2_ostream.h
View File

@ -47,13 +47,13 @@ public:
|| defined BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
typedef const void* Const_void_ptr;
operator Const_void_ptr () const {
if ( m_os)
return *m_os;
if ( m_os->fail() )
return 0;
else
return static_cast<Const_void_ptr>(m_os);
}
#else
explicit operator bool ()
{
explicit operator bool () {
return m_os && !m_os->fail();
}
#endif

3
Maintenance/infrastructure/magritte.geometryfactory.com/autocgalrc
View File

@ -1,7 +1,7 @@
PATH=$PATH:/usr/local/bin
export PATH
CGAL_TESTER="cgaltester"
CGAL_TESTER_NAME="GeometryFactory"
CGAL_TESTER_NAME="magritte (GF)"
CGAL_TESTER_ADDRESS=sebastien.loriot@geometryfactory.com
CGAL_ROOT=$HOME/cgal_test
LOGS_DIR="${CGAL_ROOT}/AUTOTEST_LOGS"
@ -26,6 +26,7 @@ COMPILERS_localhost="${COMPILERS_localhost} x86-64_Darwin-13.0_Apple-clang-3.2_R
COMPILERS_localhost="${COMPILERS_localhost} x86-64_Darwin-13.0_Apple-clang-3.2_Debug"
COMPILERS_localhost="${COMPILERS_localhost} x86-64_Darwin-13.0_Apple-clang-3.2_Release"
COMPILERS_localhost="${COMPILERS_localhost} x86-64_Darwin-13.0_Apple-clang-5.0_Release"
COMPILERS_localhost="${COMPILERS_localhost} x86-64_Darwin-13.0_Apple-clang-5.0_Release-cpp11"
COMPILERS_localhost="${COMPILERS_localhost} x86-64_Darwin-13.0_Apple-llvm-gcc-4.2_Release"
BUILD_ON_localhost=all

5
Maintenance/infrastructure/magritte.geometryfactory.com/reference_platforms/x86-64_Darwin-13.0_Apple-clang-3.2_Release-cpp11/setup
View File

@ -1,9 +1,10 @@
CXX=/usr/bin/clang++
CC=/usr/bin/clang
CXXFLAGS="-Wall -Wextra -std=c++11 -stdlib=libc++ -pipe"
export CXX CC CXXFLAGS
BOOST_LIBRARYDIR=/Users/cgaltester/boost-cpp11/boost_1_54_0/stage/lib
BOOST_INCLUDEDIR=/Users/cgaltester/boost-cpp11/boost_1_54_0
DYLD_LIBRARY_PATH=$BOOST_LIBRARYDIR:$DYLD_LIBRARY_PATH
export BOOST_LIBRARYDIR BOOST_INCLUDEDIR DYLD_LIBRARY_PATH
CXXFLAGS="-Wall -Wextra -std=c++11 -stdlib=libc++ -pipe -I$BOOST_INCLUDEDIR"
export CXX CC CXXFLAGS

1763
Maintenance/infrastructure/magritte.geometryfactory.com/reference_platforms/x86-64_Darwin-13.0_Apple-clang-5.0_Release-cpp11/CMakeCache.txt Normal file
View File

File diff suppressed because it is too large Load Diff

10
Maintenance/infrastructure/magritte.geometryfactory.com/reference_platforms/x86-64_Darwin-13.0_Apple-clang-5.0_Release-cpp11/setup Normal file
View File

@ -0,0 +1,10 @@
CXX=/Library/Developer/CommandLineTools/usr/bin/clang++
CC=/Library/Developer/CommandLineTools/usr/bin/clang
BOOST_LIBRARYDIR=/Users/cgaltester/boost-cpp11/boost_1_54_0/stage/lib
BOOST_INCLUDEDIR=/Users/cgaltester/boost-cpp11/boost_1_54_0
DYLD_LIBRARY_PATH=$BOOST_LIBRARYDIR:$DYLD_LIBRARY_PATH
export BOOST_LIBRARYDIR BOOST_INCLUDEDIR DYLD_LIBRARY_PATH
CXXFLAGS="-Wall -Wextra -std=c++11 -stdlib=libc++ -pipe -I$BOOST_INCLUDEDIR"
export CXX CC CXXFLAGS

5
Maintenance/infrastructure/magritte.geometryfactory.com/reference_platforms/x86-64_Darwin-13.0_Apple-clang-5.0_Release/setup
View File

@ -1,9 +1,10 @@
CXX=/Library/Developer/CommandLineTools/usr/bin/clang++
CC=/Library/Developer/CommandLineTools/usr/bin/clang
CXXFLAGS="-Wall -Wextra"
export CXX CC CXXFLAGS
BOOST_LIBRARYDIR=/Users/cgaltester/boost-cpp11/boost_1_54_0/stage/lib
BOOST_INCLUDEDIR=/Users/cgaltester/boost-cpp11/boost_1_54_0
DYLD_LIBRARY_PATH=$BOOST_LIBRARYDIR:$DYLD_LIBRARY_PATH
export BOOST_LIBRARYDIR BOOST_INCLUDEDIR DYLD_LIBRARY_PATH
CXXFLAGS="-Wall -Wextra -I$BOOST_INCLUDEDIR"
export CXX CC CXXFLAGS

12
Maintenance/infrastructure/picasso.geometryfactory.com/autocgalrc
View File

@ -3,15 +3,10 @@ CGAL_ROOT="/cygdrive/c/cgal/test"
BUILD_HOSTS="localhost"
REFERENCE_PLATFORMS_DIR="c:/cgal/reference_platforms"
CGAL_TESTER="afabri"
CGAL_TESTER_NAME="Andreas Fabri"
CGAL_TESTER_NAME="picasso (GF)"
CGAL_TESTER_ADDRESS="andreas.fabri@geometryfactory.com"
COMPILERS_localhost=""
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2008-Debug-64bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2008-Release-32bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2010-Debug-32bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2010-Release-64bits"
#COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2010-Release-64bits-LEDA"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2012-Release-32bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2012-Release-64bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2012-Debug-64bits"
@ -19,6 +14,11 @@ COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2013-Release-3
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2013-Release-64bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2013-Debug-64bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2013-Debug-32bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2010-Debug-32bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2010-Release-64bits"
#COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2010-Release-64bits-LEDA"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2008-Debug-64bits"
COMPILERS_localhost="$COMPILERS_localhost x64_Cygwin-Windows8_MSVC2008-Release-32bits"
MYSHELL="bash --login"
FTP_OPTS="-v -n"

3
Maintenance/infrastructure/picasso.geometryfactory.com/reference_platforms/x64_Cygwin-Windows8_MSVC2008-Release-32bits/setup
View File

@ -3,3 +3,6 @@ export VC_VERSION="9"
export ARCH="32"
export PLATFORM_REFERENCE="/cygdrive/c/CGAL/reference_platforms"
source "${PLATFORM_REFERENCE}/setup_common"
COLLECT_DEMOS_BINARIES=y
export COLLECT_DEMOS_BINARIES

2
Maintenance/infrastructure/picasso.geometryfactory.com/reference_platforms/x64_Cygwin-Windows8_MSVC2013-Debug-32bits/CMakeCache.txt
View File

@ -894,7 +894,7 @@ WITH_CGAL_Core:BOOL=ON
WITH_CGAL_ImageIO:BOOL=ON
//Enable CGAL component CGAL_Qt3
WITH_CGAL_Qt3:BOOL=ON
WITH_CGAL_Qt3:BOOL=OFF
//Enable CGAL component CGAL_Qt4
WITH_CGAL_Qt4:BOOL=ON

2
Maintenance/infrastructure/picasso.geometryfactory.com/reference_platforms/x64_Cygwin-Windows8_MSVC2013-Debug-64bits/CMakeCache.txt
View File

@ -894,7 +894,7 @@ WITH_CGAL_Core:BOOL=ON
WITH_CGAL_ImageIO:BOOL=ON
//Enable CGAL component CGAL_Qt3
WITH_CGAL_Qt3:BOOL=ON
WITH_CGAL_Qt3:BOOL=OFF
//Enable CGAL component CGAL_Qt4
WITH_CGAL_Qt4:BOOL=ON

2
Maintenance/infrastructure/picasso.geometryfactory.com/reference_platforms/x64_Cygwin-Windows8_MSVC2013-Release-32bits/CMakeCache.txt
View File

@ -894,7 +894,7 @@ WITH_CGAL_Core:BOOL=ON
WITH_CGAL_ImageIO:BOOL=ON
//Enable CGAL component CGAL_Qt3
WITH_CGAL_Qt3:BOOL=ON
WITH_CGAL_Qt3:BOOL=OFF
//Enable CGAL component CGAL_Qt4
WITH_CGAL_Qt4:BOOL=ON

2
Maintenance/infrastructure/picasso.geometryfactory.com/reference_platforms/x64_Cygwin-Windows8_MSVC2013-Release-64bits/CMakeCache.txt
View File

@ -894,7 +894,7 @@ WITH_CGAL_Core:BOOL=ON
WITH_CGAL_ImageIO:BOOL=ON
//Enable CGAL component CGAL_Qt3
WITH_CGAL_Qt3:BOOL=ON
WITH_CGAL_Qt3:BOOL=OFF
//Enable CGAL component CGAL_Qt4
WITH_CGAL_Qt4:BOOL=ON

2
Maintenance/infrastructure/renoir.geometryfactory.com/.autocgalrc
View File

@ -1,7 +1,7 @@
# -*- mode: shell-script -*-
CGAL_TESTER="lrineau"
CGAL_TESTER_NAME="GeometryFactory"
CGAL_TESTER_NAME="renoir (GF)"
CGAL_TESTER_ADDRESS=Laurent.Rineau__cgal_testsuite@normalesup.org
MYSHELL="/bin/sh -c"
LC_ALL=C

39
Maintenance/infrastructure/renoir.geometryfactory.com/reference-platforms/x86-64_Linux-Fedora19_IntelCompiler-14.0-with-g++-4.8-STL/CMakeCache.txt
View File

@ -7,7 +7,7 @@
# The syntax for the file is as follows:
# KEY:TYPE=VALUE
# KEY is the name of a variable in the cache.
# TYPE is a hint to GUI's for the type of VALUE, DO NOT EDIT TYPE!.
# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
# VALUE is the current value for the KEY.
########################
@ -124,7 +124,7 @@ CMAKE_BUILD_TYPE:STRING=Release
CMAKE_COLOR_MAKEFILE:BOOL=ON
//CXX compiler.
CMAKE_CXX_COMPILER:FILEPATH=/no-raid/opt/intel/composer_xe_2013_sp1/bin/icpc
CMAKE_CXX_COMPILER:FILEPATH=/opt/intel/composer_xe_2013_sp1/bin/icpc
//User-defined flags
CMAKE_CXX_FLAGS:STRING=-w1 -fp-model strict
@ -144,7 +144,7 @@ CMAKE_CXX_FLAGS_RELEASE:STRING=-O3
CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
//C compiler.
CMAKE_C_COMPILER:FILEPATH=/no-raid/opt/intel/composer_xe_2013_sp1/bin/icc
CMAKE_C_COMPILER:FILEPATH=/opt/intel/composer_xe_2013_sp1/bin/icc
//Flags used by the compiler during all build types.
CMAKE_C_FLAGS:STRING=
@ -242,6 +242,21 @@ CMAKE_SKIP_INSTALL_RPATH:BOOL=OFF
//If set, runtime paths are not added when using shared libraries.
CMAKE_SKIP_RPATH:BOOL=OFF
//Flags used by the linker during the creation of static libraries.
CMAKE_STATIC_LINKER_FLAGS:STRING=
//Flags used by the linker during debug builds.
CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING=
//Flags used by the linker during release minsize builds.
CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING=
//Flags used by the linker during release builds.
CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING=
//Flags used by the linker during Release with Debug Info builds.
CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING=
//Path to a program.
CMAKE_STRIP:FILEPATH=/usr/bin/strip
@ -1159,7 +1174,7 @@ X11_xf86misc_INCLUDE_PATH:PATH=/usr/include
X11_xf86vmode_INCLUDE_PATH:PATH=/usr/include
//Path to a program.
XIAR:FILEPATH=/no-raid/opt/intel/composer_xe_2013_sp1/bin/xiar
XIAR:FILEPATH=/opt/intel/composer_xe_2013_sp1/bin/xiar
//Path to a file.
ZLIB_INCLUDE_DIR:PATH=/usr/include
@ -1256,7 +1271,7 @@ CGAL_Core_LIBRARY-ADVANCED:INTERNAL=1
//Variable hidden from user
CGAL_Core_LIBRARY_INSTALLED:INTERNAL=/usr/local/lib/libCGAL_Core.so
//Variable hidden from user
CGAL_ESSENTIAL_3RD_PARTY_LIBRARIES:INTERNAL=GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR
CGAL_ESSENTIAL_3RD_PARTY_LIBRARIES:INTERNAL=GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR
CGAL_EXECUTABLE_TARGETS:INTERNAL=
//Variable hidden from user
CGAL_EXT_LIB_BLAS_PREFIX:INTERNAL=BLAS
@ -1344,7 +1359,7 @@ CMAKE_CACHE_MAJOR_VERSION:INTERNAL=2
//Minor version of cmake used to create the current loaded cache
CMAKE_CACHE_MINOR_VERSION:INTERNAL=8
//Patch version of cmake used to create the current loaded cache
CMAKE_CACHE_PATCH_VERSION:INTERNAL=11
CMAKE_CACHE_PATCH_VERSION:INTERNAL=12
//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
//Path to CMake executable.
@ -1460,6 +1475,16 @@ CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SKIP_RPATH
CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS
CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG
CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE
CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STRIP
CMAKE_STRIP-ADVANCED:INTERNAL=1
//Suppress Warnings that are meant for the author of the CMakeLists.txt
@ -1479,7 +1504,7 @@ FIND_PACKAGE_MESSAGE_DETAILS_GMP:INTERNAL=[/usr/lib64/libgmp.so][/usr/include][v
//Details about finding MPFR
FIND_PACKAGE_MESSAGE_DETAILS_MPFR:INTERNAL=[/usr/lib64/libmpfr.so][/usr/include][v()]
//Details about finding OpenGL
FIND_PACKAGE_MESSAGE_DETAILS_OpenGL:INTERNAL=[/usr/lib64/libGL.so][v()]
FIND_PACKAGE_MESSAGE_DETAILS_OpenGL:INTERNAL=[/usr/lib64/libGL.so][/usr/include][v()]
//Details about finding Threads
FIND_PACKAGE_MESSAGE_DETAILS_Threads:INTERNAL=[TRUE][v()]
//Details about finding X11

2
Maintenance/infrastructure/renoir.geometryfactory.com/reference-platforms/x86-64_Linux-Fedora19_IntelCompiler-14.0-with-g++-4.8-STL/setup
View File

@ -1,4 +1,4 @@
source /opt/intel/composer_xe_2013_sp1.1.106/bin/compilervars.sh intel64
source /opt/intel/composer_xe_2013_sp1/bin/compilervars.sh intel64
CXX=icpc
CC=icc
CXXFLAGS="-w1"

33
Maintenance/infrastructure/renoir.geometryfactory.com/reference-platforms/x86-64_Linux-Fedora19_IntelCompiler-14.0-with-g++-4.8-STL_strict-ansi/CMakeCache.txt
View File

@ -7,7 +7,7 @@
# The syntax for the file is as follows:
# KEY:TYPE=VALUE
# KEY is the name of a variable in the cache.
# TYPE is a hint to GUI's for the type of VALUE, DO NOT EDIT TYPE!.
# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
# VALUE is the current value for the KEY.
########################
@ -242,6 +242,21 @@ CMAKE_SKIP_INSTALL_RPATH:BOOL=OFF
//If set, runtime paths are not added when using shared libraries.
CMAKE_SKIP_RPATH:BOOL=OFF
//Flags used by the linker during the creation of static libraries.
CMAKE_STATIC_LINKER_FLAGS:STRING=
//Flags used by the linker during debug builds.
CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING=
//Flags used by the linker during release minsize builds.
CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING=
//Flags used by the linker during release builds.
CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING=
//Flags used by the linker during Release with Debug Info builds.
CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING=
//Path to a program.
CMAKE_STRIP:FILEPATH=/usr/bin/strip
@ -1256,7 +1271,7 @@ CGAL_Core_LIBRARY-ADVANCED:INTERNAL=1
//Variable hidden from user
CGAL_Core_LIBRARY_INSTALLED:INTERNAL=/usr/local/lib/libCGAL_Core.so
//Variable hidden from user
CGAL_ESSENTIAL_3RD_PARTY_LIBRARIES:INTERNAL=GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR
CGAL_ESSENTIAL_3RD_PARTY_LIBRARIES:INTERNAL=GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR;GMP;MPFR
CGAL_EXECUTABLE_TARGETS:INTERNAL=
//Variable hidden from user
CGAL_EXT_LIB_BLAS_PREFIX:INTERNAL=BLAS
@ -1344,7 +1359,7 @@ CMAKE_CACHE_MAJOR_VERSION:INTERNAL=2
//Minor version of cmake used to create the current loaded cache
CMAKE_CACHE_MINOR_VERSION:INTERNAL=8
//Patch version of cmake used to create the current loaded cache
CMAKE_CACHE_PATCH_VERSION:INTERNAL=11
CMAKE_CACHE_PATCH_VERSION:INTERNAL=12
//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
//Path to CMake executable.
@ -1460,6 +1475,16 @@ CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SKIP_RPATH
CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS
CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG
CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE
CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STRIP
CMAKE_STRIP-ADVANCED:INTERNAL=1
//Suppress Warnings that are meant for the author of the CMakeLists.txt
@ -1479,7 +1504,7 @@ FIND_PACKAGE_MESSAGE_DETAILS_GMP:INTERNAL=[/usr/lib64/libgmp.so][/usr/include][v
//Details about finding MPFR
FIND_PACKAGE_MESSAGE_DETAILS_MPFR:INTERNAL=[/usr/lib64/libmpfr.so][/usr/include][v()]
//Details about finding OpenGL
FIND_PACKAGE_MESSAGE_DETAILS_OpenGL:INTERNAL=[/usr/lib64/libGL.so][v()]
FIND_PACKAGE_MESSAGE_DETAILS_OpenGL:INTERNAL=[/usr/lib64/libGL.so][/usr/include][v()]
//Details about finding Threads
FIND_PACKAGE_MESSAGE_DETAILS_Threads:INTERNAL=[TRUE][v()]
//Details about finding X11

2
Maintenance/infrastructure/renoir.geometryfactory.com/reference-platforms/x86-64_Linux-Fedora19_IntelCompiler-14.0-with-g++-4.8-STL_strict-ansi/setup
View File

@ -1,4 +1,4 @@
source /opt/intel/composer_xe_2013_sp1.1.106/bin/compilervars.sh intel64
source /opt/intel/composer_xe_2013_sp1/bin/compilervars.sh intel64
CXX=icpc
CC=icc
CXXFLAGS="-strict-ansi -w1 -diag-disable 11"

11
Maintenance/public_release/announcement/mailing-beta → Maintenance/public_release/announcement/mailing-beta.eml
View File

@ -1,4 +1,5 @@
Subject: CGAL 4.4 Beta 1 Released, Computational Geometry Algorithms Library
Content-Type: text/plain; charset="utf-8"
Body:
The CGAL Open Source Project is pleased to announce the release 4.4 Beta 1
@ -12,6 +13,12 @@ release of the final version of CGAL 4.4 mid-March.
Besides fixes to existing packages, the following has changed since
CGAL 4.3:
o New compiler support
The Apple Clang compiler version 5.0 is now supported on
OS X Mavericks.
o Triangulated Surface Mesh Segmentation (new package)
This package implements the segmentation of triangulated surface meshes
@ -20,6 +27,10 @@ CGAL 4.3:
the SDF.
Note that Microsoft Visual Studio 2013, and its VC++ 12 compiler are not
yet supported.
See http://www.cgal.org/releases.html for a complete list of changes.

0
Maintenance/public_release/announcement/mailing → Maintenance/public_release/announcement/mailing.eml
View File

2
Maintenance/public_release/scripts/prepare_release
View File

@ -32,7 +32,7 @@ printf "Copy documentation to doc_html/ and doc_html_online/...\n"
[ -d "$DEST_DIR" ] || mkdir "$DEST_DIR"
[ -d "$DEST_DIR/doc_html" ] || mkdir "$DEST_DIR/doc_html"
[ -d "/var/CGAL/www/${PUBLIC_RELEASE_NAME#CGAL-}/Manual" ] || mkdir "/var/CGAL/www/${PUBLIC_RELEASE_NAME#CGAL-}/Manual"
[ -d "/var/CGAL/www/${PUBLIC_RELEASE_NAME#CGAL-}/Manual" ] || mkdir -p "/var/CGAL/www/${PUBLIC_RELEASE_NAME#CGAL-}/Manual"
cp "$PUBLIC_RELEASE_DIR"/*(.) "${RELEASE_CANDIDATES_DIR}/$PUBLIC_RELEASE_NAME"
cp -a "$MANUAL_TESTS_DIR/$INTERNAL_RELEASE"/output/* "$DEST_DIR/doc_html"

3
Maintenance/release_building/public_release_name
View File

@ -1 +1,2 @@
CGAL-4.4-dev
CGAL-4.4-beta2

1
Mesh_3/demo/Mesh_3/Volume_plane_interface.h
View File

@ -5,6 +5,7 @@
#include <QGLViewer/qglviewer.h>
#include <CGAL_demo/Scene_item.h>
#include <iostream>
#include <QGLViewer/manipulatedFrame.h>
class Volume_plane_interface : public Scene_item {
Q_OBJECT

2
Mesh_3/examples/Mesh_3/mesh_3D_image_variable_size.cpp
View File

@ -1,3 +1,5 @@
#define CGAL_MESH_3_VERBOSE
#include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
#include <CGAL/Mesh_triangulation_3.h>

3
Mesh_3/examples/Mesh_3/mesh_implicit_sphere.cpp
View File

@ -31,7 +31,8 @@ FT sphere_function (const Point& p)
int main()
{
// Domain (Warning: Sphere_3 constructor uses squared radius !)
Mesh_domain domain(sphere_function, K::Sphere_3(CGAL::ORIGIN, 2.));
Mesh_domain domain(sphere_function,
K::Sphere_3(CGAL::ORIGIN, 2.));
// Mesh criteria
Mesh_criteria criteria(facet_angle=30, facet_size=0.1, facet_distance=0.025,

3
Mesh_3/examples/Mesh_3/mesh_implicit_sphere_variable_size.cpp
View File

@ -45,7 +45,8 @@ FT sphere_function (const Point& p)
int main()
{
// Domain (Warning: Sphere_3 constructor uses squared radius !)
Mesh_domain domain(sphere_function, K::Sphere_3(CGAL::ORIGIN, 2.));
Mesh_domain domain(sphere_function,
K::Sphere_3(CGAL::ORIGIN, 2.));
// Mesh criteria
Spherical_sizing_field size;

3
Mesh_3/examples/Mesh_3/mesh_two_implicit_spheres_with_balls.cpp
View File

@ -53,7 +53,8 @@ FT sphere_function (const Point& p)
int main()
{
// Domain (Warning: Sphere_3 constructor uses squared radius !)
Mesh_domain domain(sphere_function, K::Sphere_3(Point(1, 0, 0), 6.));
Mesh_domain domain(sphere_function,
K::Sphere_3(Point(1, 0, 0), 6.));
// Mesh criteria
Mesh_criteria criteria(edge_size = 0.15,

8
Mesh_3/include/CGAL/Implicit_mesh_domain_3.h
View File

@ -31,6 +31,7 @@
# pragma warning(disable:4180) // qualifier applied to function type has no meaning; ignored
#endif
#include <CGAL/Random.h>
#include <CGAL/Mesh_3/Labeled_mesh_domain_3.h>
#include <CGAL/Mesh_3/Implicit_to_labeled_function_wrapper.h>
@ -47,7 +48,7 @@ template<class Function,
class BGT,
class Wrapper = Mesh_3::Implicit_to_labeled_function_wrapper<Function,BGT> >
class Implicit_mesh_domain_3
: public Mesh_3::Labeled_mesh_domain_3<Wrapper, BGT >
: public Mesh_3::Labeled_mesh_domain_3<Wrapper, BGT>
{
public:
/// Base type
@ -66,8 +67,9 @@ public:
*/
Implicit_mesh_domain_3(const Function& f,
const Sphere_3& bounding_sphere,
const FT& error_bound = FT(1e-3))
: Base(Wrapper(f), bounding_sphere, error_bound) {}
const FT& error_bound = FT(1e-3),
CGAL::Random* p_rng = NULL)
: Base(Wrapper(f), bounding_sphere, error_bound, p_rng) {}
/// Destructor
virtual ~Implicit_mesh_domain_3() {}

9
Mesh_3/include/CGAL/Labeled_image_mesh_domain_3.h
View File

@ -27,7 +27,7 @@
#ifndef CGAL_LABELED_IMAGE_MESH_DOMAIN_3_H
#define CGAL_LABELED_IMAGE_MESH_DOMAIN_3_H
#include <CGAL/Random.h>
#include <CGAL/Mesh_3/Labeled_mesh_domain_3.h>
#include <CGAL/Mesh_3/Image_to_labeled_function_wrapper.h>
@ -41,6 +41,7 @@ namespace CGAL {
*/
template<class Image,
class BGT,
class Wrapper = Mesh_3::Image_to_labeled_function_wrapper<Image, BGT> >
class Labeled_image_mesh_domain_3
: public Mesh_3::Labeled_mesh_domain_3<Wrapper, BGT>
@ -55,10 +56,12 @@ public:
/// Constructor
Labeled_image_mesh_domain_3(const Image& image,
const FT& error_bound = FT(1e-3))
const FT& error_bound = FT(1e-3),
CGAL::Random* p_rng = NULL)
: Base(Wrapper(image),
compute_bounding_box(image),
error_bound)
error_bound,
p_rng)
{}
/// Destructor

44
Mesh_3/include/CGAL/Mesh_3/Labeled_mesh_domain_3.h
View File

@ -38,6 +38,7 @@
#include <boost/optional.hpp>
#include <CGAL/tuple.h>
#include <CGAL/Origin.h>
#include <CGAL/Random.h>
namespace CGAL {
@ -55,7 +56,8 @@ namespace Mesh_3 {
* tags of it's incident subdomain.
* Thus, a boundary facet of the domain is labelled <0,b>, where b!=0.
*/
template<class Function, class BGT>
template<class Function,
class BGT>
class Labeled_mesh_domain_3
{
public:
@ -94,14 +96,20 @@ public:
*/
Labeled_mesh_domain_3(const Function& f,
const Sphere_3& bounding_sphere,
const FT& error_bound = FT(1e-3));
const FT& error_bound = FT(1e-3),
CGAL::Random* p_rng = NULL);
Labeled_mesh_domain_3(const Function& f,
const Bbox_3& bbox,
const FT& error_bound = FT(1e-3));
const FT& error_bound = FT(1e-3),
CGAL::Random* p_rng = NULL);
/// Destructor
virtual ~Labeled_mesh_domain_3() {}
virtual ~Labeled_mesh_domain_3()
{
if(delete_rng_)
delete p_rng_;
}
/**
* Constructs a set of \ccc{n} points on the surface, and output them to
@ -461,6 +469,9 @@ private:
const Function function_;
/// The bounding box
const Iso_cuboid_3 bbox_;
/// The random number generator used by Construct_initial_points
CGAL::Random* p_rng_;
bool delete_rng_;
/// Error bound relative to sphere radius
FT squared_error_bound_;
@ -483,24 +494,40 @@ template<class F, class BGT>
Labeled_mesh_domain_3<F,BGT>::Labeled_mesh_domain_3(
const F& f,
const Sphere_3& bounding_sphere,
const FT& error_bound )
const FT& error_bound,
CGAL::Random* p_rng)
: function_(f)
, bbox_(iso_cuboid(bounding_sphere.bbox()))
, p_rng_(p_rng)
, delete_rng_(false)
, squared_error_bound_(squared_error_bound(bounding_sphere,error_bound))
{
// TODO : CGAL_ASSERT(0 < f(bounding_sphere.get_center()) ) ?
if(!p_rng_)
{
p_rng_ = new CGAL::Random(0);
delete_rng_ = true;
}
}
template<class F, class BGT>
Labeled_mesh_domain_3<F,BGT>::Labeled_mesh_domain_3(
const F& f,
const Bbox_3& bbox,
const FT& error_bound )
const FT& error_bound,
CGAL::Random* p_rng)
: function_(f)
, bbox_(iso_cuboid(bbox))
, p_rng_(p_rng)
, delete_rng_(false)
, squared_error_bound_(squared_error_bound(bbox_,error_bound))
{
// TODO : CGAL_ASSERT(0 < f(bounding_sphere.get_center()) ) ?
if(!p_rng_)
{
p_rng_ = new CGAL::Random(0);
delete_rng_ = true;
}
}
@ -522,8 +549,9 @@ Labeled_mesh_domain_3<F,BGT>::Construct_initial_points::operator()(
const double radius = std::sqrt(CGAL::to_double(squared_radius));
Random_points_on_sphere_3 random_point_on_sphere(radius);
Random_points_in_sphere_3 random_point_in_sphere(radius);
CGAL::Random& rng = *(r_domain_.p_rng_);
Random_points_on_sphere_3 random_point_on_sphere(radius, rng);
Random_points_in_sphere_3 random_point_in_sphere(radius, rng);
// Get some functors
typename BGT::Construct_segment_3 segment_3 =

9
Mesh_3/include/CGAL/Mesh_domain_with_polyline_features_3.h
View File

@ -448,6 +448,15 @@ public:
, current_curve_index_(1)
, curves_aabb_tree_is_built(false) {}
template <typename T1, typename T2, typename T3>
Mesh_domain_with_polyline_features_3(const T1& o1,
const T2& o2,
T3& o3)
: Base(o1, o2, o3)
, current_corner_index_(1)
, current_curve_index_(1)
, curves_aabb_tree_is_built(false) {}
#ifndef CGAL_CFG_NO_CPP0X_VARIADIC_TEMPLATES
template <typename ... T>
Mesh_domain_with_polyline_features_3(const T& ...t)

78
Mesh_3/include/CGAL/Polyhedral_mesh_domain_3.h
View File

@ -36,6 +36,7 @@
#include <CGAL/AABB_traits.h>
#include <sstream>
#include <CGAL/Random.h>
#include <CGAL/point_generators_3.h>
#include <CGAL/Mesh_3/Creator_weighted_point_3.h>
#include <CGAL/Mesh_3/Profile_counter.h>
@ -203,36 +204,57 @@ public:
Polyhedral_mesh_domain_3()
: tree_()
, bounding_tree_(&tree_)
, has_cache(false) {}
, has_cache(false)
, p_rng_(NULL)
, delete_rng_(true)
{
p_rng_ = new CGAL::Random(0);
}
/**
* @brief Constructor. Contruction from a polyhedral surface
* @param polyhedron the polyhedron describing the polyhedral surface
*/
Polyhedral_mesh_domain_3(const Polyhedron& p)
Polyhedral_mesh_domain_3(const Polyhedron& p,
CGAL::Random* p_rng = NULL)
: tree_(TriangleAccessor().triangles_begin(p),
TriangleAccessor().triangles_end(p)),
bounding_tree_(&tree_) // the bounding tree is tree_
, has_cache(false)
, p_rng_(p_rng)
, delete_rng_(false)
{
if(!p.is_pure_triangle()) {
std::cerr << "Your input polyhedron must be triangulated!\n";
CGAL_error_msg("Your input polyhedron must be triangulated!");
}
if(!p_rng_)
{
p_rng_ = new CGAL::Random(0);
delete_rng_ = true;
}
}
Polyhedral_mesh_domain_3(const Polyhedron& p,
const Polyhedron& bounding_polyhedron)
const Polyhedron& bounding_polyhedron,
CGAL::Random* p_rng = NULL)
: tree_(TriangleAccessor().triangles_begin(p),
TriangleAccessor().triangles_end(p))
, bounding_tree_(new AABB_tree_(TriangleAccessor().triangles_begin(bounding_polyhedron),
TriangleAccessor().triangles_end(bounding_polyhedron)))
, has_cache(false)
, p_rng_(p_rng)
, delete_rng_(false)
{
tree_.insert(TriangleAccessor().triangles_begin(bounding_polyhedron),
TriangleAccessor().triangles_end(bounding_polyhedron));
tree_.build();
bounding_tree_->build();
if(!p_rng_)
{
p_rng_ = new CGAL::Random(0);
delete_rng_ = true;
}
}
/**
@ -249,8 +271,11 @@ public:
template <typename InputPolyhedraPtrIterator>
Polyhedral_mesh_domain_3(InputPolyhedraPtrIterator begin,
InputPolyhedraPtrIterator end,
const Polyhedron& bounding_polyhedron)
: has_cache(false)
const Polyhedron& bounding_polyhedron,
CGAL::Random* p_rng = NULL)
: has_cache(false)
, p_rng_(p_rng)
, delete_rng_(false)
{
if(begin != end) {
for(; begin != end; ++begin) {
@ -270,6 +295,11 @@ public:
TriangleAccessor().triangles_end(bounding_polyhedron));
bounding_tree_ = &tree_;
}
if(!p_rng_)
{
p_rng_ = new CGAL::Random(0);
delete_rng_ = true;
}
}
/**
@ -284,8 +314,11 @@ public:
*/
template <typename InputPolyhedraPtrIterator>
Polyhedral_mesh_domain_3(InputPolyhedraPtrIterator begin,
InputPolyhedraPtrIterator end)
: has_cache(false)
InputPolyhedraPtrIterator end,
CGAL::Random* p_rng = NULL)
: has_cache(false)
, p_rng_(p_rng)
, delete_rng_(false)
{
if(begin != end) {
for(; begin != end; ++begin) {
@ -295,6 +328,11 @@ public:
tree_.build();
}
bounding_tree_ = 0;
if(!p_rng_)
{
p_rng_ = new CGAL::Random(0);
delete_rng_ = true;
}
}
/// Destructor
@ -302,6 +340,8 @@ public:
if(bounding_tree_ != 0 && bounding_tree_ != &tree_) {
delete bounding_tree_;
}
if(delete_rng_)
delete p_rng_;
}
/**
@ -595,6 +635,10 @@ private:
mutable Cached_query cached_query;
mutable AABB_primitive_id cached_primitive_id;
//random number generator for Construct_initial_points
CGAL::Random* p_rng_;
bool delete_rng_;
public:
template <typename Query>
@ -611,6 +655,17 @@ public:
return has_cache && (cached_query == Cached_query(q));
}
void set_random_generator(CGAL::Random* p_rng)
{
if(!p_rng_)
{
p_rng_ = new CGAL::Random(0);
delete_rng_ = true;
}
else
p_rng_ = p_rng;
}
private:
// Disabled copy constructor & assignment operator
typedef Polyhedral_mesh_domain_3 Self;
@ -623,7 +678,8 @@ private:
template<typename P_, typename IGT_, typename TA, typename Tag, typename E_tag_>
template<typename P_, typename IGT_, typename TA,
typename Tag, typename E_tag_>
template<class OutputIterator>
OutputIterator
Polyhedral_mesh_domain_3<P_,IGT_,TA,Tag,E_tag_>::
@ -638,7 +694,8 @@ Construct_initial_points::operator()(OutputIterator pts,
FT( (bbox.ymin() + bbox.ymax()) / 2),
FT( (bbox.zmin() + bbox.zmax()) / 2) );
Random_points_on_sphere_3<Point_3> random_point(1.);
CGAL::Random& rng = *(r_domain_.p_rng_);
Random_points_on_sphere_3<Point_3> random_point(1., rng);
int i = n;
#ifdef CGAL_MESH_3_VERBOSE
@ -678,7 +735,8 @@ Construct_initial_points::operator()(OutputIterator pts,
}
template<typename P_, typename IGT_, typename TA, typename Tag, typename E_tag_>
template<typename P_, typename IGT_, typename TA,
typename Tag, typename E_tag_>
typename Polyhedral_mesh_domain_3<P_,IGT_,TA,Tag,E_tag_>::Subdomain
Polyhedral_mesh_domain_3<P_,IGT_,TA,Tag,E_tag_>::
Is_in_domain::operator()(const Point_3& p) const

18
Mesh_3/include/CGAL/Polyhedral_mesh_domain_with_features_3.h
View File

@ -28,6 +28,7 @@
#include <CGAL/Mesh_3/config.h>
#include <CGAL/Random.h>
#include <CGAL/Polyhedral_mesh_domain_3.h>
#include <CGAL/Mesh_domain_with_polyline_features_3.h>
#include <CGAL/Mesh_polyhedron_3.h>
@ -93,11 +94,10 @@ public:
typedef CGAL::Tag_true Has_features;
/// Constructors
Polyhedral_mesh_domain_with_features_3(const Polyhedron& p);
Polyhedral_mesh_domain_with_features_3(const std::string& filename);
template <typename T1, typename T2>
Polyhedral_mesh_domain_with_features_3(const T1& a, const T2& b) : Base(a, b) {}
Polyhedral_mesh_domain_with_features_3(const Polyhedron& p,
CGAL::Random* p_rng = NULL);
Polyhedral_mesh_domain_with_features_3(const std::string& filename,
CGAL::Random* p_rng = NULL);
template <typename T1, typename T2, typename T3>
Polyhedral_mesh_domain_with_features_3(const T1& a, const T2& b, const T3& c)
@ -127,17 +127,20 @@ private:
template < typename GT_, typename P_, typename TA_,
typename Tag_, typename E_tag_>
Polyhedral_mesh_domain_with_features_3<GT_,P_,TA_,Tag_,E_tag_>::
Polyhedral_mesh_domain_with_features_3(const Polyhedron& p)
Polyhedral_mesh_domain_with_features_3(const Polyhedron& p,
CGAL::Random* p_rng)
: Base()
, polyhedron_(p)
{
this->add_primitives(polyhedron_);
this->set_random_generator(p_rng);
}
template < typename GT_, typename P_, typename TA_,
typename Tag_, typename E_tag_>
Polyhedral_mesh_domain_with_features_3<GT_,P_,TA_,Tag_,E_tag_>::
Polyhedral_mesh_domain_with_features_3(const std::string& filename)
Polyhedral_mesh_domain_with_features_3(const std::string& filename,
CGAL::Random* p_rng)
: Base()
, polyhedron_()
{
@ -145,6 +148,7 @@ Polyhedral_mesh_domain_with_features_3(const std::string& filename)
std::ifstream input(filename.c_str());
input >> polyhedron_;
this->add_primitives(polyhedron_);
this->set_random_generator(p_rng);
}

5
Mesh_3/test/Mesh_3/test_meshing_3D_image.cpp
View File

@ -50,7 +50,10 @@ public:
//-------------------------------------------------------
Image image;
image.read("data/liver.inr.gz");
Mesh_domain domain(image,1e-9);
std::cout << "\tSeed is\t"
<< CGAL::default_random.get_seed() << std::endl;
Mesh_domain domain(image, 1e-9, &CGAL::default_random);
// Set mesh criteria
Facet_criteria facet_criteria(25, 20*image.vx(), 5*image.vx());

6
Mesh_3/test/Mesh_3/test_meshing_determinism.cpp
View File

@ -38,8 +38,10 @@ int main(int argc, char* argv[])
double exude_bound = 15.;
// Domain
std::cout << "\tSeed is\t 0" << std::endl;
Mesh_domain domain("data/cube.off");
//no random generator is given, so CGAL::Random(0) is used
// Get sharp features
domain.detect_features();
@ -56,8 +58,6 @@ int main(int argc, char* argv[])
output_c3t3.reserve(5 * nb_runs);
for(std::size_t i = 0; i < nb_runs; ++i)
{
CGAL::default_random = CGAL::Random(0);
std::cout << "------- Iteration " << (i+1) << " -------" << std::endl;
C3t3 c3t3 = CGAL::make_mesh_3<C3t3>(domain, criteria,
no_perturb(),

6
Mesh_3/test/Mesh_3/test_meshing_implicit_function.cpp
View File

@ -57,8 +57,12 @@ struct Implicit_tester : public Tester<K>
//-------------------------------------------------------
// Data generation
//-------------------------------------------------------
std::cout << "\tSeed is\t"
<< CGAL::default_random.get_seed() << std::endl;
Mesh_domain domain(Implicit_tester<K>::sphere_function,
Sphere_3(CGAL::ORIGIN,2.));
Sphere_3(CGAL::ORIGIN,2.),
1e-3,
&CGAL::default_random);
// Set mesh criteria
Facet_criteria facet_criteria(0, 0, 0.3);

6
Mesh_3/test/Mesh_3/test_meshing_polyhedron.cpp
View File

@ -51,8 +51,10 @@ struct Polyhedron_tester : public Tester<K>
std::ifstream input("data/sphere.off");
input >> polyhedron;
input.close();
Mesh_domain domain(polyhedron);
std::cout << "\tSeed is\t"
<< CGAL::default_random.get_seed() << std::endl;
Mesh_domain domain(polyhedron, &CGAL::default_random);
// Set mesh criteria
Facet_criteria facet_criteria(30, 0.2, 0.02);

4
Mesh_3/test/Mesh_3/test_meshing_polyhedron_with_features.cpp
View File

@ -51,7 +51,9 @@ struct Polyhedron_with_features_tester : public Tester<K>
//-------------------------------------------------------
// Data generation
//-------------------------------------------------------
Mesh_domain domain("data/cube.off");
std::cout << "\tSeed is\t"
<< CGAL::default_random.get_seed() << std::endl;
Mesh_domain domain("data/cube.off", &CGAL::default_random);
domain.detect_features();
// Set mesh criteria

4
Mesh_3/test/Mesh_3/test_meshing_polylines_only.cpp
View File

@ -46,7 +46,9 @@ int main(int argc, char** argv)
Point(0, 1, 0),
Point(0, 0, 1));
Mesh_domain domain(p);
std::cout << "\tSeed is\t"
<< CGAL::default_random.get_seed() << std::endl;
Mesh_domain domain(p, &CGAL::default_random);
typedef std::vector<K::Point_3> Polyline;
typedef std::vector<Polyline> Polylines;

2
Modular_arithmetic/doc/Modular_arithmetic/Concepts/Modularizable.h
View File

@ -20,7 +20,7 @@ which can not be represented.
\cgalHasModel `int`
\cgalHasModel `long`
\cgalHasModel `CGAL::CORE::BigInt`
\cgalHasModel `CORE::BigInt`
\cgalHasModel `CGAL::Gmpz`
\cgalHasModel `leda_integer`
\cgalHasModel `mpz_class`

3
Polyhedron/demo/Polyhedron/MainWindow.cpp
View File

@ -45,6 +45,9 @@
#include "Show_point_dialog.h"
#include "File_loader_dialog.h"
#include <QGLViewer/manipulatedCameraFrame.h>
#include <QGLViewer/manipulatedFrame.h>
#ifdef QT_SCRIPT_LIB
# include <QScriptEngine>
# include <QScriptValue>

1
Polyhedron/demo/Polyhedron/Viewer.cpp
View File

@ -4,6 +4,7 @@
#include "Scene_draw_interface.h"
#include <QMouseEvent>
#include <QKeyEvent>
#include <QGLViewer/manipulatedCameraFrame.h>
class Viewer_impl {
public:

1
Polyhedron_IO/examples/Polyhedron_IO/off2iv.cpp
View File

@ -81,6 +81,7 @@ int main( int argc, char **argv) {
CGAL::Inventor_ostream os( *p_out);
CGAL::File_writer_inventor writer;
CGAL::generic_copy_OFF( *p_in, *p_out, writer);
if(!os) return EXIT_FAILURE;
os.close();
vout << " .... done." << endl;

2
Polyhedron_IO/examples/Polyhedron_IO/off2vrml.cpp
View File

@ -87,11 +87,13 @@ int main( int argc, char **argv) {
CGAL::VRML_1_ostream os( *p_out);
CGAL::File_writer_inventor writer;
CGAL::generic_copy_OFF( *p_in, *p_out, writer);
if(!os) return EXIT_FAILURE;
os.close();
} else {
CGAL::VRML_2_ostream os( *p_out);
CGAL::File_writer_VRML_2 writer;
CGAL::generic_copy_OFF( *p_in, *p_out, writer);
if(!os) return EXIT_FAILURE;
os.close();
}
vout << " .... done." << endl;

2
STL_Extension/doc/STL_Extension/CGAL/utility.h
View File

@ -426,6 +426,7 @@ Equivalent to `Quadruple<T1, T2, T3, T4>(x, y, z, w)`.
template <class T1, class T2, class T3, class T4>
Quadruple<T1, T2, T3, T4> make_tuple(T1 x, T2 y, T3 z, T4 w);
#ifndef DOXYGEN_RUNNING
/*!
\ingroup PkgStlExtensionUtilities
Creates a pair `(t1,t2)` if `comp(t1,t2)==true` and `(t2,t1)` otherwise.
@ -440,5 +441,6 @@ std::pair<T,T> make_sorted_pair(T t1, T t2, Compare comp)
{
return comp(t1, t2) ? std::make_pair(t1,t2) : std::make_pair(t2,t1);
}
#endif
} /* end namespace CGAL */

1
STL_Extension/doc/STL_Extension/PackageDescription.txt
View File

@ -48,7 +48,6 @@
- `CGAL::cpp11::prev`
- `CGAL::predecessor`
- `CGAL::successor`
- `CGAL::make_sorted_pair`
## Iterators and Iterator/Circulator Adaptors ##
- `CGAL::Dispatch_output_iterator<V,O>`

3
STL_Extension/test/STL_Extension/test_Compact_container.cpp
View File

@ -9,6 +9,8 @@
#include <CGAL/Random.h>
#include <CGAL/Testsuite/use.h>
#include <CGAL/use.h>
struct Node_1
: public CGAL::Compact_container_base
@ -108,6 +110,7 @@ void test(const Cont &)
assert(check_empty(c1));
typename Cont::allocator_type t20 = c0.get_allocator();
CGAL_USE(t20);
std::cout << "Now filling some containers" << std::endl;

2
Scripts/developer_scripts/create_internal_release
View File

@ -223,7 +223,7 @@ sub create_version_file()
{
#if VERSION starts with CGAL-, we remove "CGAL-" from version
#the $newver variable will store the right version
if ($result = $VERSION =~ /CGAL-(.*)/){
if ($VERSION =~ /CGAL-(.*)/) {
$newver = $1;
} else {
$newver = $VERSION;

9
Scripts/developer_scripts/create_new_release
View File

@ -243,6 +243,7 @@ sed -i -e "s/define CGAL_SVN_REVISION .*/define CGAL_SVN_REVISION $CGAL_SVN_REVI
sed -i -e "s/define CGAL_GIT_HASH .*/define CGAL_GIT_HASH $CGAL_GIT_HASH/" include/CGAL/version.h
cd ..
# Make the release tarball
rm -f "${release_name}".tar*
tar -cf "${release_name}.tar" "${release_name}"
gzip "${release_name}.tar"
cp "${release_name}.tar.gz" "${HTML_DIR}"
@ -316,6 +317,7 @@ if [ -n "$DO_PUBLIC" ]; then
# popd
# cp -a doc_html/* ${public_release_name}/doc_html
rm -f "${public_release_name}".tar*
tar -cf "${public_release_name}.tar" "${public_release_name}"
mkdir "${HTML_DIR}/${release_name}-public"
xz --best "${public_release_name}.tar" -c > "${HTML_DIR}/${release_name}-public/${public_release_name}.tar.xz"
@ -342,6 +344,7 @@ fi
if [ -n "$DO_PUBLIC" ]; then
# Build the Windows installer
rm -rf "${public_release_name}-NSIS"
mkdir ${public_release_name}-NSIS
mv ${public_release_name} ${public_release_name}-NSIS
cp ${SOURCES_DIR}/wininst/developer_scripts/* ${public_release_name}-NSIS
@ -355,12 +358,12 @@ if [ -n "$DO_PUBLIC" ]; then
fi
# Remove local directory and tarball
rm -rf ${release_name}
rm -rf "${release_name}"
rm ${release_name}.tar.gz
if [ -n "$DO_PUBLIC" ]; then
rm -rf ${public_release_name}-NSIS
rm -rf "${public_release_name}-NSIS"
rm -rf doc
# rm -rf doc_tex
rm -rf doc_html
rm ${public_release_name}.tar.gz ${public_release_name}.zip
rm "${public_release_name}.tar.gz" "${public_release_name}.zip"
fi

4
Spatial_searching/doc/Spatial_searching/CGAL/Search_traits_adapter.h
View File

@ -12,7 +12,7 @@ in a nearest neighbor search algorithm, this class must be used as distance.
`Key` is a type that is associated to a point of type `Base_distance::Point_d`.
`PointPropertyMap` is a model of `ReadablePropertyMap`
`PointPropertyMap` is a model of `LvaluePropertyMap`
with `Key` as `key_type` and `Base_distance::Point_d` as `value_type`.
`Base_distance` is a model of either `GeneralDistance` or `OrthogonalDistance`.
@ -84,7 +84,7 @@ must be used as distance.
`Key` is a type that is associated to a point of type `Base_distance::Point_d`.
`PointPropertyMap` is a model of `ReadablePropertyMap`
`PointPropertyMap` is a model of `LvaluePropertyMap`
with `Key` as `key_type` and `Base_distance::Point_d` as `value_type`.
`BaseTraits` is a model of either `SearchTraits` or `RangeSearchTraits`.

2
Spatial_searching/doc/Spatial_searching/PackageDescription.txt
View File

@ -79,7 +79,7 @@ classes that are described in the reference pages.
- `CGAL::Euclidean_distance_sphere_point<Traits>`
- `CGAL::Manhattan_distance_iso_box_point<Traits>`
- `CGAL::Weighted_Minkowski_distance<Traits>`
- `CGAL::Distance_for_point_adapter<Key,PointPropertyMap,Base_distance>`
- `CGAL::Distance_adapter<Key,PointPropertyMap,Base_distance>`
## %Splitter Classes ##
- `CGAL::Sliding_midpoint<Traits, SpatialSeparator>`

12
Spatial_searching/examples/Spatial_searching/searching_with_point_with_info_inplace.cpp
View File

@ -12,21 +12,23 @@ typedef Kernel::Point_3 Point_3;
typedef std::size_t Point;
//definition of the property map and get
//function as friend function to have access to
//private member
//definition of a non-mutable lvalue property map,
//with the get function as a friend function to give it
//access to the private member
class My_point_property_map{
const std::vector<Point_3>& points;
public:
typedef Point_3 value_type;
typedef const value_type& reference;
typedef Point key_type;
typedef boost::readable_property_map_tag category;
typedef boost::lvalue_property_map_tag category;
My_point_property_map(const std::vector<Point_3>& pts):points(pts){}
reference operator[](key_type k) const {return points[k];}
friend reference get(const My_point_property_map& ppmap,key_type i)
{return ppmap.points[i];}
{return ppmap[i];}
};

19
Spatial_searching/include/CGAL/Search_traits_adapter.h
View File

@ -22,15 +22,12 @@
#define CGAL_SEARCH_TRAITS_WITH_INFO
#include <CGAL/Kd_tree_rectangle.h>
#include <boost/mpl/has_xxx.hpp>
#include <CGAL/Euclidean_distance.h> //for default distance specialization
#include <CGAL/property_map.h>
#include <boost/version.hpp>
#if BOOST_VERSION >= 104000
#include <boost/property_map/property_map.hpp>
#else
#include <boost/property_map.hpp>
#endif
#include <boost/mpl/has_xxx.hpp>
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
namespace CGAL{
@ -74,6 +71,10 @@ struct Get_iso_box_d<T,true>
template <class Point_with_info,class PointPropertyMap,class Base_traits>
class Search_traits_adapter : public Base_traits{
PointPropertyMap ppmap;
BOOST_STATIC_ASSERT( ( boost::is_same< boost::lvalue_property_map_tag,
typename boost::property_traits<PointPropertyMap>::category
>::value ) );
public:
typedef Base_traits Base;
typedef typename internal::Get_iso_box_d<Base>::type Iso_box_d;
@ -126,6 +127,10 @@ template <class Point_with_info,class PointPropertyMap,class Base_distance>
class Distance_adapter : public Base_distance {
PointPropertyMap ppmap;
typedef typename Base_distance::FT FT;
BOOST_STATIC_ASSERT( ( boost::is_same< boost::lvalue_property_map_tag,
typename boost::property_traits<PointPropertyMap>::category
>::value ) );
public:
Distance_adapter( const PointPropertyMap& ppmap_=PointPropertyMap(),

5
Spatial_searching/test/Spatial_searching/Building_kd_tree_with_ddim_points.cpp
View File

@ -27,8 +27,9 @@ typedef CGAL::K_neighbor_search<SearchTraits> K_neighbor_searc
typedef Orthogonal_k_neighbor_search::Distance Distance;
//typdefs for Point_with_info
typedef Point_with_info_helper<SearchTraits::Point_d>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,SearchTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Point_property_map,Distance> Distance_adapter;
typedef Point_property_map<SearchTraits::Point_d> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,SearchTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Ppmap,Distance> Distance_adapter;
typedef CGAL::Orthogonal_k_neighbor_search<Traits_with_info,Distance_adapter> Orthogonal_k_neighbor_search_with_info;
typedef CGAL::K_neighbor_search<Traits_with_info,Distance_adapter> K_neighbor_search_with_info;

5
Spatial_searching/test/Spatial_searching/Building_kd_tree_with_own_pointtype.cpp
View File

@ -16,8 +16,9 @@ typedef CGAL::Search_traits<double, Point, const double*, Construct_coord_iterat
typedef CGAL::Orthogonal_k_neighbor_search<Traits, Distance> K_neighbor_search;
//typdefs for Point_with_info
typedef Point_with_info_helper<Point>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,Traits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Point_property_map,Distance> Distance_adapter;
typedef Point_property_map<Point> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,Traits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Ppmap,Distance> Distance_adapter;
typedef CGAL::Orthogonal_k_neighbor_search<Traits_with_info, Distance_adapter> K_neighbor_search_with_info;
const unsigned int N = 1000;

3
Spatial_searching/test/Spatial_searching/Circular_query.cpp
View File

@ -23,7 +23,8 @@ typedef CGAL::Counting_iterator<Random_points_iterator> N_Random_points_iterator
typedef CGAL::Search_traits_2<K> Traits;
//for Point_with_info
typedef Point_with_info_helper<Point>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,Traits> Traits_with_info;
typedef Point_property_map<Point> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,Traits> Traits_with_info;
template <class Traits>

3
Spatial_searching/test/Spatial_searching/Iso_rectangle_2_query.cpp
View File

@ -21,7 +21,8 @@ typedef CGAL::Random_points_in_square_2<Point> Random_points_iterator;
typedef CGAL::Counting_iterator<Random_points_iterator> N_Random_points_iterator;
typedef CGAL::Search_traits_2<K> Traits;
typedef Point_with_info_helper<Point>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,Traits> Traits_with_info;
typedef Point_property_map<Point> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,Traits> Traits_with_info;
template <class SearchTraits>
void run(std::list<Point> all_points)

5
Spatial_searching/test/Spatial_searching/K_neighbor_search_manhattan_distance_isobox_point.cpp
View File

@ -16,8 +16,9 @@ typedef CGAL::Manhattan_distance_iso_box_point<TreeTraits> Distance;
typedef CGAL::K_neighbor_search<TreeTraits, Distance> Neighbor_search;
//typdefs for Point_with_info
typedef Point_with_info_helper<Point_d>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Point_property_map,Distance> Distance_adapter;
typedef Point_property_map<Point_d> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Ppmap,Distance> Distance_adapter;
typedef CGAL::K_neighbor_search<Traits_with_info, Distance_adapter> Neighbor_search_with_info;
const unsigned int K = 8;

5
Spatial_searching/test/Spatial_searching/K_neighbor_search_with_circle.cpp
View File

@ -21,8 +21,9 @@ typedef CGAL::K_neighbor_search<TreeTraits, Distance> Neighbor_search;
typedef CGAL::Random_points_in_square_2<Point> Random_points_iterator;
//typdefs for Point_with_info
typedef Point_with_info_helper<Point>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Point_property_map,Distance> Distance_adapter;
typedef Point_property_map<Point> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Ppmap,Distance> Distance_adapter;
typedef CGAL::K_neighbor_search<Traits_with_info, Distance_adapter> Neighbor_search_with_info;

5
Spatial_searching/test/Spatial_searching/Orthogonal_incremental_neighbor_search.cpp
View File

@ -39,8 +39,9 @@ typedef Orthogonal_incremental_neighbor_search::iterator NN_iterator;
typedef Orthogonal_incremental_neighbor_search::Point_with_transformed_distance Point_with_transformed_distance;
//typdefs for Point_with_info
typedef Point_with_info_helper<Point>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Point_property_map,Distance> Distance_adapter;
typedef Point_property_map<Point> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Ppmap,Distance> Distance_adapter;
typedef CGAL::Incremental_neighbor_search<Traits_with_info,Distance_adapter> Orthogonal_incremental_neighbor_search_with_info;

5
Spatial_searching/test/Spatial_searching/Orthogonal_k_neighbor_search.cpp
View File

@ -16,8 +16,9 @@ typedef CGAL::Search_traits_2<K> TreeTrai
typedef CGAL::Orthogonal_k_neighbor_search<TreeTraits> Neighbor_search;
//typdefs fo Point_with_info
typedef Point_with_info_helper<Point>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Point_property_map,Neighbor_search::Distance> Distance_adapter;
typedef Point_property_map<Point> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Ppmap,Neighbor_search::Distance> Distance_adapter;
typedef CGAL::Orthogonal_k_neighbor_search<Traits_with_info,Distance_adapter> Neighbor_search_with_info;
template <class K_search>

15
Spatial_searching/test/Spatial_searching/Point_with_info.h
View File

@ -16,17 +16,24 @@ struct Point_with_info_helper{
typedef My_point_with_info<Point_> type;
};
template <class Point>
struct Point_property_map{
template <class Point>
friend const Point& get(Point_property_map,const My_point_with_info<Point>& p) {return p.point();}
typedef Point value_type;
typedef const value_type& reference;
typedef const My_point_with_info<Point>& key_type;
typedef boost::lvalue_property_map_tag category;
reference operator[](key_type k) const {return k.point();}
friend reference get(const Point_property_map& ppmap, key_type i)
{return ppmap[i];}
};
template <class Point>
const Point& get_point(const Point& p) {return p;}
template <class Point>
const Point& get_point(const My_point_with_info<Point>& p) {return get(Point_property_map(),p);}
const Point& get_point(const My_point_with_info<Point>& p) {return get(Point_property_map<Point>(),p);}
template <class Point>
struct Create_point_with_info : public std::unary_function<Point,Point>{

3
Spatial_searching/test/Spatial_searching/Range_searching.cpp
View File

@ -19,7 +19,8 @@ typedef CGAL::Counting_iterator<Random_points_iterator> N_Random_points_iterator
typedef CGAL::Search_traits_3<K> Traits;
//for Point_with_info
typedef Point_with_info_helper<Point>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,Traits> Traits_with_info;
typedef Point_property_map<Point> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,Traits> Traits_with_info;
const int N=10000;

5
Spatial_searching/test/Spatial_searching/Splitters.cpp
View File

@ -29,8 +29,9 @@ typedef CGAL::Search_traits_3<K> TreeTraits;
typedef CGAL::Euclidean_distance<TreeTraits> Distance;
#endif
typedef Point_with_info_helper<Point>::type Point_with_info;
typedef CGAL::Search_traits_adapter<Point_with_info,Point_property_map,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Point_property_map,Distance> Distance_adapter;
typedef Point_property_map<Point> Ppmap;
typedef CGAL::Search_traits_adapter<Point_with_info,Ppmap,TreeTraits> Traits_with_info;
typedef CGAL::Distance_adapter <Point_with_info,Ppmap,Distance> Distance_adapter;
typedef std::vector<Point> Vector;

2
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Edge_collapse_visitor_base.h
View File

@ -13,7 +13,7 @@ and the derived visitor will never be used polymorphically at runtime (is perfec
and hide a non-virtual method in the context of the static polymorphism used in the simplification algorithm).
\tparam ECM is the type of surface being simplified, and must be a model of the `EdgeCollapsableMesh` concept.
\tparam ECM is the type of surface mesh being simplified, and must be a model of the `EdgeCollapsableSurfaceMesh` concept.
\cgalModels `EdgeCollapseSimplificationVisitor`

38
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Constrained_placement.h Normal file
View File

@ -0,0 +1,38 @@
namespace CGAL {
namespace Surface_mesh_simplification {
/*!
\ingroup PkgSurfaceMeshSimplification
The class `Constrained_placement` is a model for the `GetPlacement` concept
provided the template parameter `BasePlacement` is such a model.
The placement of the vertex resulting from a contraction of an edge adjacent to a constrained edge
is the point of the common vertex. Otherwise the placement is the one computed by `BasePlacement`.
\tparam BasePlacement a model of `GetPlacement`.
\tparam EdgeIsConstrainedMap a model of `boost::ReadablePropertyMap` with `GetPlacement::Profile::edge_descriptor`
as key type and `bool` as value type indicating if an edge is constrained.
\cgalModels `GetPlacement`
*/
template<class BasePlacement, class EdgeIsConstrainedMap>
class Constrained_placement : public BasePlacement
{
public:
/// \name Creation
/// @{
/*!
Constructor
*/
Constrained_placement(
EdgeIsConstrainedMap map=EdgeIsConstrainedMap(),
BasePlacement base= BasePlacement() );
/// @}
}; /* end Surface_mesh_simplification::Midpoint_placement */
} /* end namespace Surface_Mesh_Simplification */
} /* end namespace CGAL */

2
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_ratio_stop_predicate.h
View File

@ -8,7 +8,7 @@ namespace Surface_mesh_simplification {
The class `Count_ratio_stop_predicate` is a model for the `StopPredicate` concept
which returns `true` when the relation between the initial and current number of edges drops below a certain ratio.
\tparam ECM is the type of surface being simplified, and must be a model of the `EdgeCollapsableMesh` concept.
\tparam ECM is the type of surface mesh being simplified, and must be a model of the `EdgeCollapsableSurfaceMesh` concept.
\cgalModels `StopPredicate`

2
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Count_stop_predicate.h
View File

@ -8,7 +8,7 @@ namespace Surface_mesh_simplification {
The class `Count_stop_predicate` is a model for the `StopPredicate` concept,
which returns `true` when the number of current edges drops below a certain threshold.
\tparam ECM is the type of surface being simplified, and must be a model of the `EdgeCollapsableMesh` concept.
\tparam ECM is the type of surface mesh being simplified, and must be a model of the `EdgeCollapsableSurfaceMesh` concept.
\cgalModels `StopPredicate`

2
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_length_cost.h
View File

@ -8,7 +8,7 @@ namespace Surface_mesh_simplification {
The class `Edge_length_cost` is a model for the `GetCost` concept,
which computes the collapse cost as the squared length of the edge.
\tparam ECM is the type of surface being simplified, and must be a model of the `EdgeCollapsableMesh` concept.
\tparam ECM is the type of surface mesh being simplified, and must be a model of the `EdgeCollapsableSurfaceMesh` concept.
\cgalModels `GetCost`

2
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Edge_profile.h
View File

@ -7,7 +7,7 @@ namespace Surface_mesh_simplification {
The class `Edge_profile` provides a model for the `EdgeProfile` concept.
\tparam ECM is the type of surface being simplified, and must be a model of the `EdgeCollapsableMesh` concept.
\tparam ECM is the type of surface mesh being simplified, and must be a model of the `EdgeCollapsableSurfaceMesh` concept.
\cgalModels `EdgeProfile`

2
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_cost.h
View File

@ -8,7 +8,7 @@ The class `LindstromTurk_cost` provides a model for the `GetCost` concept.
It computes the collapse cost following the Lindstrom-Turk strategy
(Section \ref SurfaceMeshSimplificationLindstromTurkStrategy)
\tparam ECM is the type of surface being simplified, and must be a model of the `EdgeCollapsableMesh` concept.
\tparam ECM is the type of surface mesh being simplified, and must be a model of the `EdgeCollapsableSurfaceMesh` concept.
\cgalModels `GetCost`

2
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/LindstromTurk_placement.h
View File

@ -10,7 +10,7 @@ It computes the placement, that is, the new position for the remaining vertex af
a halfedge-collapse, following the Lindstrom-Turk strategy
(Section \ref SurfaceMeshSimplificationLindstromTurkStrategy).
\tparam ECM is the type of surface being simplified, and must be a model of the `EdgeCollapsableMesh` concept.
\tparam ECM is the type of surface mesh being simplified, and must be a model of the `EdgeCollapsableSurfaceMesh` concept.
\cgalModels `GetPlacement`

2
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/Policies/Edge_collapse/Midpoint_placement.h
View File

@ -8,7 +8,7 @@ namespace Surface_mesh_simplification {
The class `Midpoint_placement` is a model for the `GetPlacement` concept
which computes the placement as the midpoint position along the edge.
\tparam ECM is the type of surface being simplified, and must be a model of the `EdgeCollapsableMesh` concept.
\tparam ECM is the type of surface mesh being simplified, and must be a model of the `EdgeCollapsableSurfaceMesh` concept.
\cgalModels `GetPlacement`

68
Surface_mesh_simplification/doc/Surface_mesh_simplification/CGAL/Surface_mesh_simplification/edge_collapse.h
View File

@ -4,15 +4,15 @@ namespace Surface_mesh_simplification {
/*!
\ingroup PkgSurfaceMeshSimplification
Simplifies `surface` in-place by collapsing edges, and returns
Simplifies `surface_mesh` in-place by collapsing edges, and returns
the number of edges effectively removed.
The function `Surface_mesh_simplification::edge_collapse` simplifies in-place a triangulated surface mesh by iteratively collapsing edges.
\cgalHeading{Non-Named Parameters}
`surface` is the surface to simplify.
It must be a model of the `EdgeCollapsableMesh` concept.
`surface_mesh` is the surface mesh to simplify.
It must be a model of the `EdgeCollapsableSurfaceMesh` concept.
`should_stop` is the stop-condition policy.
It must be a model of the `StopPredicate` concept.
@ -43,56 +43,70 @@ function designates which formal argument it is.
\cgalHeading{vertex_index_map(VertexIndexMap vpm)}
Maps each vertex in the surface into an unsigned integer number
in the range `[0,num_vertices(surface))`.
Maps each vertex in the surface mesh into an unsigned integer number
in the range `[0,num_vertices(surface_mesh))`.
`VertexIndexMap` must be a model of
`ReadablePropertyMap`
whose `key_type` is
`boost::graph_traits<EdgeCollapsableMesh const>::%vertex_descriptor`
`boost::graph_traits<EdgeCollapsableSurfaceMesh const>::%vertex_descriptor`
and whose `value_type` is
`boost::graph_traits<EdgeCollapsableMesh>::%size_type`,
`boost::graph_traits<EdgeCollapsableSurfaceMesh>::%size_type`,
<B>%Default</B>: the property map obtained by calling `get(vertex_index,surface)`,
which requires the surface vertices to have an `id()` member properly initialized to the
<B>%Default</B>: the property map obtained by calling `get(vertex_index,surface_mesh)`,
which requires the surface mesh vertices to have an `id()` member properly initialized to the
required value.
If the vertices don't have such an `id()`, you must pass some property map explicitly.
An external property map can be easily obtained by calling
`get(vertex_external_index,surface)`. This constructs on the fly, and returns,
`get(vertex_external_index,surface_mesh)`. This constructs on the fly, and returns,
a property map which non-intrusively associates a proper id with each vertex.
\cgalHeading{edge_index_map(EdgeIndexMap eim)}
Maps each <I>directed</I> edge in the surface into an unsigned integer number
in the range `[0,num_edges(surface))`.
Maps each <I>directed</I> edge in the surface mesh into an unsigned integer number
in the range `[0,num_edges(surface_mesh))`.
`EdgeIndexMap` must be a model of
`ReadablePropertyMap` whose `key_type` is
`boost::graph_traits<EdgeCollapsableMesh const>::%edge_descriptor`
`boost::graph_traits<EdgeCollapsableSurfaceMesh const>::%edge_descriptor`
and whose `value_type` is
`boost::graph_traits<EdgeCollapsableMesh>::%size_type`
`boost::graph_traits<EdgeCollapsableSurfaceMesh>::%size_type`
<B>%Default</B>: the property map obtained by calling `get(edge_index,surface)`,
which requires the surface edges to have an `id()` member properly initialized to the
<B>%Default</B>: the property map obtained by calling `get(edge_index,surface_mesh)`,
which requires the surface mesh edges to have an `id()` member properly initialized to the
require value.
If the edges don't have such an `id()`, you must pass some property map explicitly.
An external property map can be easily obtained by calling
`get(edge_external_index,surface)`. This constructs on the fly, and returns,
`get(edge_external_index,surface_mesh)`. This constructs on the fly, and returns,
a property map which non-intrusively associates a proper id with each edge.
\cgalHeading{edge_is_border_map(EdgeIsBorderMap ebm)}
Maps each <I>directed</I> edge in the surface into a Boolean value
which indicates if the edge belongs to the boundary of the surface
Maps each <I>directed</I> edge in the surface mesh into a Boolean value
which indicates if the edge belongs to the boundary of the surface mesh
(facing the outside).
`EdgeIsBorderMap` must be a model
`ReadablePropertyMap` whose `key_type` is
`boost::graph_traits<EdgeCollapsableMesh const>::%edge_descriptor`
`boost::graph_traits<EdgeCollapsableSurfaceMesh const>::%edge_descriptor`
and whose `value_type` is `bool`.
<B>%Default</B>: the property map obtained by calling `get(edge_is_border,surface)`.
<B>%Default</B>: the property map obtained by calling `get(edge_is_border,surface_mesh)`.
\cgalHeading{edge_is_constrained_map(EdgeIsConstrainedMap ecm)}
Maps each <I>undirected</I> edge in the surface mesh into a Boolean value
which indicates if the edge is constrained.
`EdgeIsConstrainedMap` must be a model
`ReadablePropertyMap` whose `key_type` is
`boost::graph_traits<EdgeCollapsableSurfaceMesh const>::%edge_descriptor`
and whose `value_type` is `bool`.
\attention If this parameter is provided, `surface_mesh` must be a model of the
`EdgeCollapsableSurfaceMeshWithConstraints` concept.
<B>%Default</B>: A property map always returning `false`, that is no edge is constrained.
\cgalHeading{get_cost(GetCost gc)}
@ -101,7 +115,7 @@ The policy which returns the collapse cost for an edge.
The type of `gc` must be a model of the `GetCost` concept.
<B>%Default</B>:
`CGAL::Surface_mesh_simplification::LindstromTurk_cost<EdgeCollapsableMesh>`.
`CGAL::Surface_mesh_simplification::LindstromTurk_cost<EdgeCollapsableSurfaceMesh>`.
\cgalHeading{get_placement(GetPlacement gp)}
@ -111,7 +125,7 @@ for an edge.
The type of `gp` must be a model of the `GetPlacement` concept.
<B>%Default</B>:
`CGAL::Surface_mesh_simplification::LindstromTurk_placement<EdgeCollapsableMesh>`
`CGAL::Surface_mesh_simplification::LindstromTurk_placement<EdgeCollapsableSurfaceMesh>`
\cgalHeading{visitor(EdgeCollapseSimplificationVisitor v)}
@ -123,7 +137,7 @@ The type of `v` must be a model of the `EdgeCollapseSimplificationVisitor` conce
<B>%Default: an implementation-defined dummy visitor</B>.
If you wish to provide your own visitor, you can derive from:
`CGAL::Surface_mesh_simplification::Edge_collapse_visitor_base<EdgeCollapsableMesh>`
`CGAL::Surface_mesh_simplification::Edge_collapse_visitor_base<EdgeCollapsableSurfaceMesh>`
and override only the callbacks you are interested in.
All these functions naming parameters are defined in
@ -137,7 +151,7 @@ named parameter with `CGAL::`, as shown in the examples in the user manual.
The simplification process continues until the `should_stop` policy returns `true`
or the surface cannot be simplified any further due to topological constraints.
or the surface mesh cannot be simplified any further due to topological constraints.
`get_cost` and `get_placement` are the policies which control
the <I>cost-strategy</I>, that is, the order in which edges are collapsed
@ -148,8 +162,8 @@ are called at certain points in the simplification code.
*/
template<class EdgeCollapsableMesh,class StopPredicate, class P, class T, class R>
int edge_collapse ( EdgeCollapsableMesh& surface
template<class EdgeCollapsableSurfaceMesh,class StopPredicate, class P, class T, class R>
int edge_collapse ( EdgeCollapsableSurfaceMesh& surface_mesh
, StopPredicate const& should_stop
, sms_named_params<P,T,R> const& named_parameters
) ;

Some files were not shown because too many files have changed in this diff Show More