mirror of https://github.com/CGAL/cgal
Documentation for the Envelope_3 package.
This commit is contained in:
Ron Wein
parent
d805e4b4d0
commit
710c660a47
|
|
@ -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}
|
||||
|
|
@ -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.
|
||||
|
|
@ -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
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
% +------------------------------------------------------------------------+
|
||||
% | Reference manual page: Env_sphere_traits.tex
|
||||
% +------------------------------------------------------------------------+
|
||||
% |
|
||||
% | Package: Envelope_3
|
||||
% |
|
||||
% +------------------------------------------------------------------------+
|
||||
|
||||
\ccRefPageBegin
|
||||
|
||||
\begin{ccRefClass}{Env_sphere_traits_3<ConicTraits>}
|
||||
|
||||
\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
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
% +------------------------------------------------------------------------+
|
||||
% | Reference manual page: Env_triangle_traits.tex
|
||||
% +------------------------------------------------------------------------+
|
||||
% |
|
||||
% | Package: Envelope_3
|
||||
% |
|
||||
% +------------------------------------------------------------------------+
|
||||
|
||||
\ccRefPageBegin
|
||||
|
||||
\begin{ccRefClass}{Env_triangle_traits_3<Kernel>}
|
||||
|
||||
\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<Kernel>} 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<Kernel>}
|
||||
|
||||
\end{ccRefClass}
|
||||
|
||||
\ccRefPageEnd
|
||||
|
|
@ -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<Curve_2,Multiplicity>}
|
||||
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<Kernel>}\\
|
||||
\ccc{CGAL::Envelope_sphere_traits_3<ConicTraits>}
|
||||
|
||||
\end{ccRefConcept}
|
||||
|
||||
\ccRefPageEnd
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
% +------------------------------------------------------------------------+
|
||||
% | Reference manual page: Envelope_diagram.tex
|
||||
% +------------------------------------------------------------------------+
|
||||
% |
|
||||
% | Package: Envelope_3
|
||||
% |
|
||||
% +------------------------------------------------------------------------+
|
||||
|
||||
\ccRefPageBegin
|
||||
|
||||
\begin{ccRefClass}{Envlope_diagram_2<EnvTraits>}
|
||||
|
||||
\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<EnvTraits>}
|
||||
|
||||
\ccTypes
|
||||
%=======
|
||||
|
||||
\ccTypedef{typedef Envelope_diagram_2<EnvTraits> Self;}{}
|
||||
\ccGlue
|
||||
\ccTypedef{typedef Arrangement_2<EnvTraits> 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<EnvTraits>::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<EnvTraits>::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<EnvTraits>::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
|
||||
|
||||
|
|
@ -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<EnvTraits>}\\
|
||||
\\
|
||||
\ccRefIdfierPage{CGAL::Env_triangle_traits_3<Kernel>}\\
|
||||
\ccRefIdfierPage{CGAL::Env_sphere_traits_3<ConicTraits>}\\
|
||||
|
||||
|
||||
|
|
@ -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<class InputIterator, class Traits>
|
||||
void lower_envelope_3 (InputIterator begin, InputIterator end,
|
||||
Envelope_diagram_2<Traits>& 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
|
||||
|
|
@ -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}
|
||||
|
||||
|
|
@ -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<class InputIterator, class Traits>
|
||||
void upper_envelope_3 (InputIterator begin, InputIterator end,
|
||||
Envelope_diagram_2<Traits>& 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
|
||||
|
|
@ -560,27 +560,34 @@ public:
|
|||
|
||||
/*! A new dcel builder with full Envelope features */
|
||||
template <class Traits, class Data>
|
||||
class Envelope_pm_dcel :
|
||||
public CGAL::Arr_dcel_base<Envelope_pm_vertex<typename Traits::Point_2, Data>,
|
||||
Envelope_pm_halfedge<typename Traits::X_monotone_curve_2, Data>,
|
||||
Envelope_pm_face<Data> >
|
||||
class Envelope_pm_dcel : public
|
||||
CGAL::Arr_dcel_base<Envelope_pm_vertex<typename Traits::Point_2,
|
||||
Data>,
|
||||
Envelope_pm_halfedge<typename Traits::X_monotone_curve_2,
|
||||
Data>,
|
||||
Envelope_pm_face<Data> >
|
||||
{
|
||||
public:
|
||||
typedef Data Face_data;
|
||||
typedef typename Envelope_pm_face<Data>::Data_iterator Face_data_iterator;
|
||||
typedef typename Envelope_pm_face<Data>::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<Data> Dcel_elem_with_data;
|
||||
typedef Data Face_data;
|
||||
typedef typename Envelope_pm_face<Data>::Data_iterator
|
||||
Face_data_iterator;
|
||||
typedef typename Envelope_pm_face<Data>::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<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() {}
|
||||
|
|
|
|||
Loading…
Reference in New Issue