diff --git a/Envelope_3/doc_tex/Envelope_3/PkgDescription.tex b/Envelope_3/doc_tex/Envelope_3/PkgDescription.tex new file mode 100644 index 00000000000..ea7253bba65 --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3/PkgDescription.tex @@ -0,0 +1,13 @@ +\begin{ccPkgDescription}{3D Envelopes\label{Pkg:Envelope3}} +\ccPkgHowToCiteCgal{cgal:mw-e3-06} +\ccPkgSummary{ +This package consits of a function that computes the lower (or upper) +envelope of a set of arbitrary surfaces in 3D. The output is +represented as an 2D envelope diagram --- a planar subdivision such +that the identity of the surface that induces the envelope on each +diagram cell is unique.} + +\ccPkgDependsOn{\ccRef[2D Arrangements]{Pkg:Arrangement2}} +\ccPkgIntroducedInCGAL{3.3} +\ccPkgLicense{\ccLicenseQPL} +\end{ccPkgDescription} diff --git a/Envelope_3/doc_tex/Envelope_3/envelope.tex b/Envelope_3/doc_tex/Envelope_3/envelope.tex new file mode 100644 index 00000000000..859495c1861 --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3/envelope.tex @@ -0,0 +1,65 @@ + +A continuous surface $S$ in $\reals^3$ is called {\em $xy$-monotone} if +every line parallel to the $z$-axis intersects it at a single point +at most. For example, the sphere $x^2 + y^2 + z^2 = 1$ is {\em not} +$xy$-monotone as the $z$-axis intersects it at $(0, 0, -1)$ and at +$(0, 0, 1)$; however, if we use the $xy$-plane to split it to an +upper hemisphere and a lower hemisphere, these two hemispheres are +$xy$-monotone. + +An $xy$-monotone surface can therefore be represented as a +bivariate function $z = S(x,y)$, defined over some continuous range +$R_S \subseteq \reals^2$. Given a set $\calS = \{ S_1, S_2, \ldots, +S_n \}$ of $xy$-monotone surfaces, their {\em lower envelope} is defined +as the point-wise minimum of all surfaces. Namely, the lower envelope +of the set $\calS$ can be defined as the following function: +\begin{eqnarray*} +\calL_{\calS} (x,y) = \min_{1 \leq k \leq n}{\overline{S}_k (x,y)} \ , +\end{eqnarray*} +where we define $\overline{S}_k(x,y) = S_k(x,y)$ for $(x,y) \in +R_{S_k}$, and $\overline{S}_k(x,y) = \infty$ otherwise. + +Similarly, the {\em upper envelope} of $\calS$ is the point-wise maximum of +the $xy$-monotone surfaces in the set: +\begin{eqnarray*} +\calU_{\calS} (x,y) = \max_{1 \leq k \leq n}{\underline{S}_k (x,y)} \ , +\end{eqnarray*} +where in this case $\underline{S}_k(x,y) = -\infty$ for $(x,y) \nin +R_{S_k}$. + +Given a set of $xy$-monotone surfaces $\calS$, the {\em minimization +diagram} of $\calS$ is a subdivision of the $xy$-plane into cells, +such that the identity of the surfaces that induce the lower diagram +over a specific cell of the subdivision (be it a face, an edge or +a vertex) is the same. In non-degenerate situatuion, a face is +induced by a single surface (or by no surfaces at all, if there are +no $xy$-monotone surfaces defined over it), and an edge is induced +by a single surface and corresponds to its projected boundary, or by +two surfaces and corresponds to their projetced intersection curve. +The {\em maximization diagram} is symmetrically defined for upper envelopes. +In the rest of this chapter, we refer to both these digrams as +{\em envelope diagrams}. + +It is easy to see that an envelope diagram is no more than a planar +arrangement (see Chapter~\ref{chapterArrangement_2}), represented +using an extended \dcel\ structure, such that every \dcel\ record +(namely each face, halfedge and vertex) stores an additional container +of it originators: the $xy$-monotone surfaces that induce this feature. + +Lower and upper envelopes can be efficiently computed using a +divide-and-conquer approach. First note that the envelope diagram for +a single $xy$-monotone curve $S_k$ is trivial to compute: we porject +the boundary of its range of definition $R_{S_k}$ onto the $xy$-plane +and label the faces it induces accordingly. Given a set $\hat{\calS}$ +of (non necessarily $xy$-monotone) surfaces in $\reals^3$, we start by +subdividing each surface into a finite number of weakly $xy$-monotone +surfaces\footnote{To handle degenerate inputs, we consider {\em vertical} +surfaces, namely pathces of planes that are perpendicular to the +$xy$-plane, as {\em weakly} $xy$-monotone.}, obtaining the set $\calS$. +We continue by splitting the set into two disjoint subsets $\calS_1$ +and $\calS_2$, and we compute their envelope diagrams recursively. +We finally have tow merge the diagrams, and we do this by overlaying +them and then applying some post-processing on the resulting diagram. +The post-processing stage is non-trivial and invloves the projection +of intersection curves onto the $xy$-plane --- +see~\cite{Michals_thesis} for more details. diff --git a/Envelope_3/doc_tex/Envelope_3/main.tex b/Envelope_3/doc_tex/Envelope_3/main.tex new file mode 100644 index 00000000000..5eae21df35f --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3/main.tex @@ -0,0 +1,34 @@ +\RCSdef{\EnvelopeSpcRefRev}{$Id$} +\RCSdefDate{\EnvelopeSpcRefDate}{$Date$} + +\ccParDims + +\ccUserChapter{Evelopes of Surfaces in 3D} + +%\input{Envelope_3/PkgDescription.tex} + +\begingroup +\label{chapter_Envelope_3} +\ccChapterAuthor{Michal Meyerovitch and Ron Wein} + +\lcTex{% + \newlength{\widthExtra}\setlength{\widthExtra}{1.1cm} + \newlength{\widthLineReal}\setlength{\widthLineReal}{\linewidth} + \addtolength{\widthLineReal}{-\widthExtra} + \newlength{\minipageSpace}\setlength{\minipageSpace}{0.2cm} + + \newlength{\widthLeft} + \newlength{\widthRight} +} + +\newcommand{\reals}{\mathbb{R}} +\newcommand{\calS}{{\cal S}} +\newcommand{\calL}{{\cal L}} +\newcommand{\calU}{{\cal U}} +\newcommand{\eps}{{\varepsilon}} +\newcommand{\dcel}{{\sc Dcel}} +\newcommand{\naive}{na\"{\i}ve} +\newcommand{\Cpp}{{C}{\tt ++}} + +\input{Envelope_3/envelope} +\endgroup diff --git a/Envelope_3/doc_tex/Envelope_3_ref/Env_sphere_traits.tex b/Envelope_3/doc_tex/Envelope_3_ref/Env_sphere_traits.tex new file mode 100644 index 00000000000..99c13405be7 --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3_ref/Env_sphere_traits.tex @@ -0,0 +1,47 @@ +% +------------------------------------------------------------------------+ +% | Reference manual page: Env_sphere_traits.tex +% +------------------------------------------------------------------------+ +% | +% | Package: Envelope_3 +% | +% +------------------------------------------------------------------------+ + +\ccRefPageBegin + +\begin{ccRefClass}{Env_sphere_traits_3} + +\ccDefinition +%============ + +The traits class \ccRefName\ is a model of the \ccc{EnvelopeTraits_3} +concept for the construction of lower and upper envelopes of spheres. +Note that when projecting the intersection curve of two spheres (a +circle in 3D) onto the $xy$-plane the resulting curve is an ellipse. +The traits class is therefore parameterized with an arrangement-traits +class that is capable of handling conic curves --- namely an instantiation +of the \ccc{Arr_conic_traits_2} class-template --- and inherits from it. + +The conic-traits class defines a nested type named \ccc{Rat_kernel}, +which is a geometric kernel parameterized with an exact rational type. +\ccRefName\ defines its \ccc{Surface_3} type to be constructible from +\ccc{Rat_kernel::Sphere_3}, namely it can handle spheres whose center +points have rational coordinates (i.e., of the type \ccc{Rat_kernel::FT}) +and whose squared radius is also rational. The \ccc{Surface_3} type is +also convertible to a \ccc{Rat_kernel::Sphere_3} object. + +The \ccc{Xy_monotone_surface_3} type is the same as the nested +\ccc{Surface_3} type. The traits-class simply ignores the upper +hemisphere when it computes lower envelopes, and ignores the lower +hemisphere when it computes upper envelopes. + +\ccInclude{CGAL/Env_sphere_traits_3.h} + +\ccIsModel + \ccc{EnvelopeTraits_3} + +\ccInheritsFrom + \ccc{ConicTraits} + +\end{ccRefClass} + +\ccRefPageEnd diff --git a/Envelope_3/doc_tex/Envelope_3_ref/Env_triangle_traits.tex b/Envelope_3/doc_tex/Envelope_3_ref/Env_triangle_traits.tex new file mode 100644 index 00000000000..c1f4ac66e3c --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3_ref/Env_triangle_traits.tex @@ -0,0 +1,53 @@ +% +------------------------------------------------------------------------+ +% | Reference manual page: Env_triangle_traits.tex +% +------------------------------------------------------------------------+ +% | +% | Package: Envelope_3 +% | +% +------------------------------------------------------------------------+ + +\ccRefPageBegin + +\begin{ccRefClass}{Env_triangle_traits_3} + +\ccDefinition +%============ + +The traits class \ccRefName\ is a model of the \ccc{EnvelopeTraits_3} +concept for the construction of lower and upper envelopes of triangles +in the space. It is parameterized with a \cgal-kernel model that is +templated in turn with a number type. To avoid numerical errors and +robustness problems, the number type should support exact rational +arithmetic --- that is, the number type should support the arithmetic +operations $+$, $-$, $\times$ and $\div$ that should be carried out +without loss of precision. For optimal performance, we recommend +instantiating the traits class with the predefined +\ccc{Exact_predicates_exact_constructions_kernel} provided by \cgal. +Using this kernel guarantees exactness and robustness, while it incurs +only a minor overhead (in comparison to working with a fast, inexact number +type) for most inputs. + +Note that when we project the boundary of a triangle, or the intersection +of two triangles, onto the $xy$-plane we obtain line segments. Indeed, +\ccRefName\ inherits from the \ccc{Arr_segment_traits_2} traits +class, and extends it by adding operations on 3D objects, namely spacial +triangles. Note that the traits class does {\sl not} define +\ccc{Kernel::Triangle_3} as its surface (and $xy$-monotone surface) type, +as one may expect. This is because the traits class needs to store extra data +with the triangles in order to efficiently operate on them. Nevertheless, +the nested \ccc{Xy_monotone_surface_3} and \ccc{Surface_3} types (in this +case both types refer to the same class, as {\sl every} triangle is (weakly) +$xy$-monotone) are however constructible from a \ccc{Kernel::Triangle_3} +instance and are also convertible an \ccc{Kernel::Triangle_3} object. + +\ccInclude{CGAL/Env_triangle_traits_3.h} + +\ccIsModel + \ccc{EnvelopeTraits_3} + +\ccInheritsFrom + \ccc{Arr_segment_traits_2} + +\end{ccRefClass} + +\ccRefPageEnd diff --git a/Envelope_3/doc_tex/Envelope_3_ref/EnvelopeTraits_3.tex b/Envelope_3/doc_tex/Envelope_3_ref/EnvelopeTraits_3.tex new file mode 100644 index 00000000000..994b75949fb --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3_ref/EnvelopeTraits_3.tex @@ -0,0 +1,182 @@ +\ccRefPageBegin + +\begin{ccRefConcept}{EnvelopeTraits_3} + +\ccDefinition +% =========== + +This concept defines the minimal set of geometric predicates and +operations needed to compute the envelope of a set of arbitrary +surfaces in $\reals^3$. It refines the arrangement-traits concept. +In addition to the \ccc{Point_2}, \ccc{X_monotone_curve_2} and +\ccc{Curve_2} types defined in the arrangement-traits concept, it +also defines the types \ccc{Surface_3} and \ccc{Xy_monotone_surface_3} +types, which represent arbitrary surfaces and $xy$-monotone surfaces, +respectively, and support some constructions and predicates on these +types. Note however, that these operations usually involve the +projection of 3D objects onto the $xy$-plane. + +\ccRefines +\ccc{ArrangementTraits_2} + +\ccTypes +% ====== + +\ccNestedType{Surface_3} +{represents an arbitrary surface in $\reals^3$.} +\ccGlue +\ccNestedType{Xy_monotone_surface_3} +{represents a weakly $xy$-monotone surface in $\reals^3$.} + +\ccHeading{Functor Types} +% ======================= + +\ccThree{Compare_y_at_x_2}{}{\hspace*{14cm}} +\ccThreeToTwo + +\ccNestedType{Construct_envelope_xy_monotone_parts_3} +{provides the operator (templated by the \ccc{OutputIterator} type)~: + \begin{itemize} + \item \ccc{OutputIterator operator() (Surface_3 S, OutputIterator oi)} \\ + which subdivides the given surface \ccc{S} into $xy$-monotone parts + and inserts them into the output iterator. + The value-type of \ccc{OutputIterator} is \ccc{Xy_monotone_surface_3}. + The operator returns a past-the-end iterator for the output sequence. + \end{itemize}} + +\ccNestedType{Construct_projected_boundary_curves_2} +{provides the operator (templated by the \ccc{OutputIterator} type)~: + \begin{itemize} + \item \ccc{OutputIterator operator() (Xy_monotone_surface_3 s, OutputIterator oi)} \\ + which computes all planar curves that form the projection of the + boundary of the given $xy$-monotone surface $s$ onto the $xy$-plane, + and inserts them into the output iterator. + The value-type of \ccc{OutputIterator} is \ccc{Curve_2}. + The operator returns a past-the-end iterator for the output sequence. + \end{itemize}} + +\ccNestedType{Construct_projected_intersections_2} +{provides the operator (templated by the \ccc{OutputIterator} type)~: + \begin{itemize} + \item \ccc{OutputIterator operator() (Xy_monotone_surface_3 s1, + Xy_monotone_surface_3 s2, + OutputIterator oi)} \\ + which computes the projection of the intersections of the + $xy$-monotone surfaces \ccc{s1} and \ccc{s2} onto the $xy$-plane, + and inserts them into the output iterator. + The value-type of \ccc{OutputIterator} is \ccc{CGAL::Object}, where + each \ccc{Object} either wraps a \ccc{pair} + instance, which represents an intersection curve with its + multiplicity (in case the multiplicity is undefined or not known, it + should be set to $0$) or an \ccc{Point_2} instance, representing the + projected image of a degenerate intersection. + The operator returns a past-the-end iterator for the output sequence. + \end{itemize}} + +\ccNestedType{Compare_distance_to_envelope_3} +{provides the operators~: + \begin{itemize} + \item \ccc{Comparison_result operator() (Point_2 p, + Xy_monotone_surface_3 s1, + Xy_monotone_surface_3 s2)}\\ + which compares the distance of the two $xy$-monotone surfaces two + the envelope at the $xy$-coordinates of the point \ccc{p}, with the + precondition that both surfaces are defined over \ccc{p}. + (Note that if we compute the lower envelope, this is the comparison + result of $s_1(p)$ and $s_2(p)$, and the opposite result if we compute + the upper envelope.) +% + \item \ccc{Comparison_result operator() (X_monotone_curve_2 c, + Xy_monotone_surface_3 s1, + Xy_monotone_surface_3 s2)}\\ + which compares the distance of the two $xy$-monotone surfaces two + the envelope over an $x$-monotone curve $c$. $c$ is a portion of the + projection of an intersection curve in $\reals^3$, with the + precondition that both surfaces are defined over \ccc{c} and their + relative $z$-order remains the same for all points on this curve. + \end{itemize}} + +\ccNestedType{Compare_distance_to_envelope_above_3} +{provides the operator~: + \begin{itemize} + \item \ccc{Comparison_result operator() (X_monotone_curve_2 c, + Xy_monotone_surface_3 s1, + Xy_monotone_surface_3 s2)}\\ + which compares the distance of the two $xy$-monotone surfaces two + the envelope immediately above their projected intersection curve + $c$ (a point $p$ is {\em above} an $x$-monotone curve $c$ if it is in + the $x$-range of $c$, and lies to its left when the curve is + traversed from its $xy$-lexicographically smaller endpoint to the + its larger endpoint). We have the precondition that both surfaces are + defined ``above'' $c$, and their relative $z$-order is the same for + some small enough neighborhood of points above $c$. + \end{itemize}} + +\ccNestedType{Compare_distance_to_envelope_below_3} +{provides the operator~: + \begin{itemize} + \item \ccc{Comparison_result operator() (X_monotone_curve_2 c, + Xy_monotone_surface_3 s1, + Xy_monotone_surface_3 s2)}\\ + which compares the distance of the two $xy$-monotone surfaces two + the envelope immediately below their projected intersection curve + $c$ (a point $p$ is {\em below} an $x$-monotone curve $c$ if it is in + the $x$-range of $c$, and lies to its right when the curve is + traversed from its $xy$-lexicographically smaller endpoint to the + its larger endpoint). We have the precondition that both surfaces are + defined ``below'' $c$, and their relative $z$-order is the same for + some small enough neighborhood of points below $c$. + \end{itemize}} + + +\ccCreation +\ccCreationVariable{traits} +% ========================= + +\ccThree{Construct_envelope_xy_monotone_parts_3~~~}{}{\hspace*{7cm}} +\ccThreeToTwo + +\ccConstructor{EnvelopeTraits_3();}{default constructor.} +\ccGlue +\ccConstructor{EnvelopeTraits_3(EnvelopeTraits_3 other);} +{copy constructor.} +\ccGlue +\ccMethod{EnvelopeTraits_3 operator=(other);}{assignment operator.} + +\ccMethod{void set_lower ();} +{sets \ccVar{} such that it computes predicates for lower-envelope + computations.} +\ccGlue +\ccMethod{void set_upper ();} +{sets \ccVar{} such that it computes predicates for upper-envelope + computations.} + +\ccHeading{Accessing Functor Objects} +%==================================== + +\ccMethod{Construct_envelope_xy_monotone_parts_3 construct_envelope_xy_monotone_parts_3_object();} +{} +\ccGlue +\ccMethod{Construct_projected_boundary_curves_2 construct_projected_boundary_curves_2_object();} +{} +\ccGlue +\ccMethod{Construct_projected_intersections_2 construct_projected_intersections_2_object();} +{} +\ccGlue +\ccMethod{Compare_distance_to_envelope_3 compare_distance_to_envelope_3_object();} +{} +\ccGlue +\ccMethod{Compare_distance_to_envelope_above_3 compare_distance_to_envelope_above_3_object();} +{} +\ccGlue +\ccMethod{Compare_distance_to_envelope_below_3 compare_distance_to_envelope_below_3_object();} +{} + +\ccHasModels +%=========== +\ccc{CGAL::Envelope_triangle_traits_3}\\ +\ccc{CGAL::Envelope_sphere_traits_3} + +\end{ccRefConcept} + +\ccRefPageEnd diff --git a/Envelope_3/doc_tex/Envelope_3_ref/Envelope_diagram.tex b/Envelope_3/doc_tex/Envelope_3_ref/Envelope_diagram.tex new file mode 100644 index 00000000000..f27c28bf25a --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3_ref/Envelope_diagram.tex @@ -0,0 +1,148 @@ +% +------------------------------------------------------------------------+ +% | Reference manual page: Envelope_diagram.tex +% +------------------------------------------------------------------------+ +% | +% | Package: Envelope_3 +% | +% +------------------------------------------------------------------------+ + +\ccRefPageBegin + +\begin{ccRefClass}{Envlope_diagram_2} + +\ccDefinition +%============ + +The class-template \ccClassTemplateName\ represents the minimization +diagram that corresponds to the lower envelope of a set of curves, or the +maximization diagram that corresponds to their upper envelope. It is +parameterized with a traits class that must be a model of the +\ccc{EnvelopeTraits_3} concept, and is basically an planar arrangement of +$x$-monotone curves, as defined by this traits class. These $x$-monotone +curves are the projections of boundary curves of $xy$-monotone surfaces, +or the intersection curves between such surfaces, onto the $xy$-plane. +It is thus possible to traverse the envelope diagram using the +methods inherited from the \ccc{Arrangement_2} class. + +The envelope diagram extends the arrangment features (namely the vertices, +halfedges and faces), such that each feature stores a container of +originators --- namely, the $xy$-monotone surfaces (instances of the type +\ccc{EnvTraits::Xy_monotone_surface_3}) that induce the lower envelop +(or the upper envelope, in case of a maximization diagram) over this +feature. The envelope diagram provides access methods to these originators. + +\ccInclude{CGAL/envelope_3.h} + +\ccInheritsFrom + \ccc{Arrangement_2} + +\ccTypes +%======= + +\ccTypedef{typedef Envelope_diagram_2 Self;}{} +\ccGlue +\ccTypedef{typedef Arrangement_2 Base;}{} + +\ccNestedType{Surface_const_iterator} +{an iterator for the $xy$-monotone surfaces that induce a diagram feature. + Its value-type is \ccc{EnvTraits::Xy_monotone_surface_3}.} + +\ccCreation +\ccCreationVariable{diag} +%======================== + +\ccConstructor{Envelope_diagram_2();} + {constructs an empty diagram containing one unbounded face, + which corresponds to the entire plane and has no originators.} + +\ccConstructor{Envelope_diagram_2 (const Self& other);} + {copy constructor.} + +\ccConstructor{Envelope_diagram_2 (EnvTraits *traits);} + {constructs an empty diagram that uses the given \ccc{traits} + instance for performing the geometric predicates.} + +%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +\subsection*{Class Envelope\_diagram\_2$<$EnvTraits$>$::Vertex} +%============================================================== + +\begin{ccClass}{Envelope_diagram_2::Vertex} + +\ccInheritsFrom + \ccc{Base::Vertex} + +\ccCreationVariable{v} +\ccAccessFunctions +%----------------- + +\ccMethod{size_t number_of_surfaces () const;} +{returns the number of $xy$-monotone surfaces that induce \ccVar.} + +\ccMethod{Surface_const_iterator surfaces_begin () const;} +{returns an iterator for the first $xy$-monotone surface that induces \ccVar.} +\ccGlue +\ccMethod{Surface_const_iterator surfaces_end () const;} +{returns a past-the-end iterator for the $xy$-monotone surfaces that induce + \ccVar.} + +\end{ccClass} + +%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +\subsection*{Class Envelope\_diagram\_2$<$EnvTraits$>$::Halfedge} +%================================================================ + +\begin{ccClass}{Envelope_diagram_2::Halfedge} + +\ccInheritsFrom + \ccc{Base::Halfedge} + +\ccCreationVariable{e} +\ccAccessFunctions +%----------------- + +\ccMethod{size_t number_of_surfaces () const;} +{returns the number of $xy$-monotone surfaces that induce \ccVar.} + +\ccMethod{Surface_const_iterator surfaces_begin () const;} +{returns an iterator for the first $xy$-monotone surface that induces \ccVar.} +\ccGlue +\ccMethod{Surface_const_iterator surfaces_end () const;} +{returns a past-the-end iterator for the $xy$-monotone surfaces that induce + \ccVar.} + +\end{ccClass} + +%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +\subsection*{Class Envelope\_diagram\_2$<$EnvTraits$>$::Face} +%============================================================ + +\begin{ccClass}{Envelope_diagram_2::Face} + +\ccInheritsFrom + \ccc{Base::Face} + +\ccCreationVariable{f} +\ccAccessFunctions +%----------------- + +\ccMethod{size_t number_of_surfaces () const;} +{returns the number of $xy$-monotone surfaces that induce \ccVar.} + +\ccMethod{Surface_const_iterator surfaces_begin () const;} +{returns an iterator for the first $xy$-monotone surface that induces \ccVar.} +\ccGlue +\ccMethod{Surface_const_iterator surfaces_end () const;} +{returns a past-the-end iterator for the $xy$-monotone surfaces that induce + \ccVar.} + +\end{ccClass} + +%~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +\end{ccRefClass} + +\ccRefPageEnd + diff --git a/Envelope_3/doc_tex/Envelope_3_ref/intro.tex b/Envelope_3/doc_tex/Envelope_3_ref/intro.tex new file mode 100644 index 00000000000..f417e13ca40 --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3_ref/intro.tex @@ -0,0 +1,28 @@ +% =============================================================== +\section*{Introduction} +\label{mink_ref_sec:intro} +% ======================= + +This package consits of a function that computes the lower (or upper) +envelope of a set of arbitrary surfaces in 3D. The output is +represented as an 2D envelope diagram --- a planar subdivision such +that the identity of the surface that induces the envelope on each +diagram cell is unique. + +\subsection*{Functions} + +\ccRefIdfierPage{CGAL::lower_envelope_3}\\ +\ccRefIdfierPage{CGAL::upper_envelope_3} + +\subsection*{Concepts} + +\ccRefConceptPage{EnvelopeTraits_3} + +\subsection*{Classes} + +\ccRefIdfierPage{CGAL::Envelope_diagram_2}\\ +\\ +\ccRefIdfierPage{CGAL::Env_triangle_traits_3}\\ +\ccRefIdfierPage{CGAL::Env_sphere_traits_3}\\ + + diff --git a/Envelope_3/doc_tex/Envelope_3_ref/lower_envelope_3.tex b/Envelope_3/doc_tex/Envelope_3_ref/lower_envelope_3.tex new file mode 100644 index 00000000000..4afc839df20 --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3_ref/lower_envelope_3.tex @@ -0,0 +1,26 @@ +% +------------------------------------------------------------------------+ +% | Reference manual page: lower_envelope_3.tex +% +------------------------------------------------------------------------+ +% | +% | Package: Envelope_3 +% | +% +------------------------------------------------------------------------+ + +\ccRefPageBegin + +\begin{ccRefFunction}{lower_envelope_3} + +\ccInclude{CGAL/envelope_3.h} + +\ccFunction{template + void lower_envelope_3 (InputIterator begin, InputIterator end, + Envelope_diagram_2& diag);} + {Computes the lower envelope of a set of surfaces in $\reals^3$, + as given by the range \ccc{[begin, end)}. The lower envelope is + represented using the output minimization diagram \ccc{diag}. + \ccPrecond{The value-type of \ccc{InputIterator} is + \ccc{Traits::Surface_2}.}} + +\end{ccRefFunction} + +\ccRefPageEnd diff --git a/Envelope_3/doc_tex/Envelope_3_ref/main.tex b/Envelope_3/doc_tex/Envelope_3_ref/main.tex new file mode 100644 index 00000000000..a8948bcbcb3 --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3_ref/main.tex @@ -0,0 +1,18 @@ +\RCSdef{\EnvelopeSpcRefRev}{$Revision$} +\RCSdefDate{\EnvelopeSpcRefDate}{$Date$} +\clearpage +\ccRefChapter{Evelopes of Surfaces in 3D} +\label{chapterEnvelope3Ref} + +\ccChapterAuthor{Michal Meyerovitch and Ron Wein} + +\newcommand{\reals}{\mathbb{R}} + +\input{Envelope_3_ref/intro} +\input{Envelope_3_ref/lower_envelope_3} +\input{Envelope_3_ref/upper_envelope_3} +\input{Envelope_3_ref/EnvelopeTraits_3} +\input{Envelope_3_ref/Env_triangle_traits} +\input{Envelope_3_ref/Env_sphere_traits} +\input{Envelope_3_ref/Envelope_diagram} + diff --git a/Envelope_3/doc_tex/Envelope_3_ref/upper_envelope_3.tex b/Envelope_3/doc_tex/Envelope_3_ref/upper_envelope_3.tex new file mode 100644 index 00000000000..9ca4d01881a --- /dev/null +++ b/Envelope_3/doc_tex/Envelope_3_ref/upper_envelope_3.tex @@ -0,0 +1,26 @@ +% +------------------------------------------------------------------------+ +% | Reference manual page: upper_envelope_3.tex +% +------------------------------------------------------------------------+ +% | +% | Package: Envelope_3 +% | +% +------------------------------------------------------------------------+ + +\ccRefPageBegin + +\begin{ccRefFunction}{upper_envelope_3} + +\ccInclude{CGAL/envelope_3.h} + +\ccFunction{template + void upper_envelope_3 (InputIterator begin, InputIterator end, + Envelope_diagram_2& diag);} + {Computes the upper envelope of a set of surfaces in $\reals^3$, + as given by the range \ccc{[begin, end)}. The lower envelope is + represented using the output maximization diagram \ccc{diag}. + \ccPrecond{The value-type of \ccc{InputIterator} is + \ccc{Traits::Surface_2}.}} + +\end{ccRefFunction} + +\ccRefPageEnd diff --git a/Envelope_3/include/CGAL/Envelope_pm_dcel.h b/Envelope_3/include/CGAL/Envelope_pm_dcel.h index a97ac111162..0fe1143b655 100644 --- a/Envelope_3/include/CGAL/Envelope_pm_dcel.h +++ b/Envelope_3/include/CGAL/Envelope_pm_dcel.h @@ -560,27 +560,34 @@ public: /*! A new dcel builder with full Envelope features */ template -class Envelope_pm_dcel : - public CGAL::Arr_dcel_base, - Envelope_pm_halfedge, - Envelope_pm_face > +class Envelope_pm_dcel : public +CGAL::Arr_dcel_base, + Envelope_pm_halfedge, + Envelope_pm_face > { public: - typedef Data Face_data; - typedef typename Envelope_pm_face::Data_iterator Face_data_iterator; - typedef typename Envelope_pm_face::Data_const_iterator Face_data_const_iterator; - typedef Data Edge_data; - typedef Face_data_iterator Edge_data_iterator; - typedef Face_data_const_iterator Edge_data_const_iterator; - typedef Data Vertex_data; - typedef Face_data_iterator Vertex_data_iterator; - typedef Face_data_const_iterator Vertex_data_const_iterator; - typedef Dcel_data Dcel_elem_with_data; + typedef Data Face_data; + typedef typename Envelope_pm_face::Data_iterator + Face_data_iterator; + typedef typename Envelope_pm_face::Data_const_iterator + Face_data_const_iterator; - typedef Data Dcel_data; - typedef Face_data_iterator Dcel_data_iterator; - typedef Face_data_const_iterator Dcel_data_const_iterator; + typedef Data Edge_data; + typedef Face_data_iterator Edge_data_iterator; + typedef Face_data_const_iterator Edge_data_const_iterator; + + typedef Data Vertex_data; + typedef Face_data_iterator Vertex_data_iterator; + typedef Face_data_const_iterator Vertex_data_const_iterator; + + typedef Dcel_data Dcel_elem_with_data; + + typedef Data Dcel_data; + typedef Face_data_iterator Dcel_data_iterator; + typedef Face_data_const_iterator Dcel_data_const_iterator; /*! Constructor */ Envelope_pm_dcel() {}