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

*** empty log message ***

This commit is contained in:
Le-Jeng Shiue 2004-04-14 04:11:57 +00:00
parent a997e05f94
commit 6cd697c345
6 changed files with 115 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Packages/Tutorial/tutorial/Polyhedron/sgp2004/paper/hds.tex
View File

@ -1,10 +1,10 @@
A halfedge data structure \cite{hds} is an edge-centered data
A halfedge data structure \cite{Weiler:1985:EDS} is an edge-centered data
structure capable of maintaining incidence informations of vertices,
edges and faces, for planar maps, polyhedron, or other orientable,
two-dimensional surfaces embedded in arbitrary dimension. Each edge is
decomposed into two halfedges with opposite orientations. Two types
of halfedge can be chosen for the data structure: facet-edge pair or
vertex-edge pair. One incident face and one incident vertex are
vertex-edge pair. One incident face and one incident vertex are
stored in each halfedge. For each face and each vertex, one incident
halfedge is stored (see Fig.\ref{fig:halfedge}). The halfedge is
designated as the connectivity primitive. Connectivity manipulations
@ -26,15 +26,15 @@ several reasons:
\label{fig:halfedge}
\end{figure}
Halfedge data structure is a combinatorial data structure. The
geometric interpretation is instantiated with a defined kernel. A
geometry kernel defines the dimensional primitives such as points and
vectors and the geometry metrics such as distances and angles. A
polyhedron is a constrained combinatorial structure that can only
represent a 2-manifold. A 2-manifold is a surface where every point is
embedded by a disk (interior points) or a half disk (boundary
points). Polyhedrons are usually interpreted as the shell of a solid
bounded by plane polygons in the 3D Euclidean space.
%% Halfedge data structure is a combinatorial data structure. The
%% geometric interpretation is instantiated with a defined kernel. A
%% geometry kernel defines the dimensional primitives such as points and
%% vectors and the geometry metrics such as distances and angles. A
%% polyhedron is a constrained combinatorial structure that can only
%% represent a 2-manifold. A 2-manifold is a surface where every point is
%% embedded by a disk (interior points) or a half disk (boundary
%% points). Polyhedrons are usually interpreted as the shell of a solid
%% bounded by plane polygons in the 3D Euclidean space.
%% In the \poly, the \hds\ is interfaced and indirectly manipulated
%% by the \poly. Since \hds\ is the internal representation of the

67
Packages/Tutorial/tutorial/Polyhedron/sgp2004/paper/intro.tex
View File

@ -11,10 +11,11 @@ structures consist almost entirely of pointers for all sort of
incidence informations. Maintaining them consistently during mesh
operations is not anymore a trivial linked-list update operation. So,
moving from a students exercise to a reliable research implementation
including maintaining and optimizing such an implementation is a
respectable software task, just imagine to introduce a back-pointer for
an existing incidence pointer and change all operations on the mesh to
handle this additional pointer consistently.
, including maintaining and optimizing such an implementation, is a
respectable software task.
%, just imagine to introduce a back-pointer for
%an existing incidence pointer and change all operations on the mesh to
%handle this additional pointer consistently.
What is common practice for simple data structures, such as linked
lists, should be common practice even more so for mesh data
@ -28,23 +29,23 @@ algorithms exists in the \emph{Computational Geometry Algorithms Library},
We will review the design of the polygonal boundary representation
\cgalpoly\ in \cgal\ that is based on the halfedge data structure.
Our main new contribution is a tutorial on how to write mesh
algorithms based on this data structure and other elements of \cgal.
Our main new contribution is \emph{a tutorial on how to write mesh
algorithms based on this data structure and other elements of \cgal}.
The tutorial consists of many example implementations of state-of-art
algorithms from recent years and an interactive visualizer that serves
as a platform, among others, for efficient experimentation and that
helps in preparing figures for publications.
The mesh algorithms that we discuss fall into three categories;
algorithms from recent years.
%and an interactive visualizer that serves
%as a platform, among others, for efficient experimentation and that
%helps in preparing figures for publications.
These mesh algorithms fall into three categories:
subdivision, remeshing, and supporting geometric algorithms. With
subdivisions algorithms, we will introduce the different approaches of
subdivision algorithms, we will introduce the different approaches of
algorithm design with the mesh data structure. Its highlight will be a
generic subdivision framework, where we excel from being mere users
generic subdivision solution, where we excel from being mere users
of \cgal, but instead we develop our own new generic library. With
remeshing algorithms we review how algorithm development based on
remeshing algorithms, we review how algorithm development based on
\cgalpoly\ and the other parts of \cgal\ enabled exciting new
implementations in research within feasible time frames. With the
auxiliary geometric algorithms we give an outlook on geometric
auxiliary geometric algorithms, we give an outlook on geometric
algorithms that are available in \cgal\ and that can be helpful in
the mesh processing context, for example, a fast self intersection
test, the smallest enclosing sphere, or the minimum width of a point set.
@ -52,13 +53,13 @@ test, the smallest enclosing sphere, or the minimum width of a point set.
We strongly believe that such a tutorial with its wealth of
information will give a head start to new research and implementations
of mesh algorithms. We also believe that it will raise the quality of
implementations: Firstly, it encourages the use of well tested and
implementations. Firstly, it encourages the use of well tested and
over time matured implementations, e.g., \cgalpoly\ in its current
design is about five years publicly released and used. Secondly, it
documents good implementation choices, e.g., the example programs can
be used as starting points for evolutionary software development.
Thirdly, it offers easy access to additional functionality, such as
the efficient self intersection test, that otherwise could be too
the efficient self intersection test, that otherwise could be too
cumbersome to implement for a research prototype.
What are potential obstacles in using a library? We want to address
@ -75,24 +76,24 @@ tutorial.
\emph{generic programming\/} and \emph{compile-time
polymorphism\/} to realize flexibility without affecting optimal
runtime.
Another argument is the interface design of \cgalpoly. Can the
abstraction into Euler operators be used for subdivision surface
algorithms without loosing performance? The comparison of the
$\sqrt{3}$ subdivision algorithm in \openmesh\ with our
implementation discussed below gives a favorable answer for our
implementation.
% Another argument is the interface design of \cgalpoly. Can the
% abstraction into Euler operators be used for subdivision surface
% algorithms without loosing performance? The comparison of the
% $\sqrt{3}$ subdivision algorithm in \openmesh\ with our
% implementation discussed below gives a favorable answer for our
% implementation.
\item
Is it small enough? Yes. The \cgalpoly\ can be tailored to store
exactly the required incidences and other required data, not more and
not less. We give the details in the next section.
not less. %We give the details in the next section.
\item
Is it flexible enough? Yes, probably. Certainly within its design
space of oriented 2-manifold meshes with boundary that was
sufficient for the range of applications illustrated with our
example programs. \cgalpoly\ cannot represent non-manifold edges,
non-manifold vertices, nor facets with multiple boundary cycles
(the facet needs to be split into several facets).
example programs.
%\cgalpoly\ cannot represent non-manifold edges,
%non-manifold vertices, nor facets with multiple boundary cycles
%(the facet needs to be split into several facets).
\item
Is it easy enough to use? Yes. This paper and the tutorial
programs are exactly the starting point for using \cgalpoly. The
@ -100,9 +101,9 @@ tutorial.
certainly a learning curve for mastering \CC\ to a decent level
including the use of templates, but it has to be emphasized that
using templated code is far easier then developing templated code.
Also, a library does not free a user to understand the data
structures and algorithms used, at least to some extend, such as
specification, runtime, and space behavior.
% Also, a library does not free a user to understand the data
% structures and algorithms used, at least to some extend, such as
% specification, runtime, and space behavior.
\item
What is the license, can I use it? Yes, we hope so. \cgal\ since
release 3.0 and our tutorial programs have open source
@ -112,7 +113,9 @@ tutorial.
\end{enumerate}
The intended audience of this paper are researchers, developers and
students in the graphics community and related fields who are
students
% in the graphics community and related fields
who are
developing algorithms with and for polygonal meshes. Prerequisites are
experience with \CC\ and templates, generic programming, basic
knowledge of edge-based data structure for meshes, and the mesh

20
Packages/Tutorial/tutorial/Polyhedron/sgp2004/paper/prereq.tex
View File

@ -1,7 +1,7 @@
\subsection{Generic Programming, \CC\ and Templates}
\cgal\ is a \CC\ library and follows in its design the \emph{generic
programming paradigm\/}~\cite{cgal:ms-aogl-94,cgal:sl-stl-95} and in
programming paradigm\/}~\cite{cgal:ms-aogl-94,cgal:sl-stl-95} and in
a few places also design patterns~\cite{Gamma:1995:DP}. Generic
programming has found wide spread acceptance in the \CC\ community
with the \emph{Standard Template Library}, \stl, as its prominent
@ -11,20 +11,18 @@ introduction and reference book~\cite{cgal:a-gps-98} coins the terms
parameter, and \emph{model\/} for all types that fulfill the set of
requirements and can thus be used as template argument. An example
function template:
\begin{lstlisting}
template <typename T>
void swap( T& a, T& b) {
T tmp = a; a = b; b = tmp;
}
\end{lstlisting}
This generic \CodeFmt{swap} function requires from the template
parameter \CodeFmt{T} to have a copy constructor and an assignment
operator. This is collectively summarized under the \emph{concept\/}
\textsc{Assignable}. Now, each builtin type, such as \CodeFmt{double},
has a copy constructor and assignment operator and thus is a
\emph{model\/} of \textsc{Assignable}. Now, in the \stl\ concepts are
\emph{model\/} of \textsc{Assignable}. In the \stl , concepts are
defined for container classes, iterators that link container classes
with algorithms, function objects that are an efficient and type safe
generalization of function pointers, allocators, and many more. In
@ -45,7 +43,6 @@ Library, started in 1995 and the first public release appeared in June
1997. \cgal\ is since its release 3.0 in November 2003 an Open Source
project initiated by a consortium of European and Israelean research
institutes with the goal to
\begin{quote}
{\em make the large body of geometric algorithms developed in the field
of computational geometry available for industrial application.}
@ -73,7 +70,7 @@ connection to the geometric primitives, predicates, and constructions.
For suitable subsets we define concepts, for example,
that are sufficient to run the two-dimensional convex hull algorithms,
and call them the \emph{geometric traits concept for two-dimensional
convex hull}. For many geometric traits classes a \cgal\ geometric
convex hull}. For many geometric traits classes, a \cgal\ geometric
kernel is a valid model.
There are many choices for a \cgal\ geometric kernel. One can choose
@ -93,7 +90,8 @@ efficiently in the conventional \CodeFmt{float} or \CodeFmt{double}
value. On the other hand, exact constructions needs a more powerful
number type in the geometric primitive coefficients that can also
represent newly constructed geometric primitives exactly. This means
usually exact long integer arithmetic. We see an example below.
usually exact long integer arithmetic.
%We see an example below.
\subsection{Edge-based Mesh Data Structures}
@ -104,7 +102,7 @@ even simple traversals in the mesh neighborhood needed case
distinctions. The key inside was the split of the edge into two
halfedges~\cite{Weiler85,Maentylae88} (also referred to as DCEL
nowadays), which allows to encode orientation in the mesh and
traversal simplifies to mere pointer traversal. Actually, the edge
traversal simplifies to mere pointer traversal. The edge
split can be done in two ways, either assigning a halfedge to each
incident facets, or assigning a halfedge to each incident
vertex~\cite{Weiler85}, these are duals of each other. Thinking of
@ -165,20 +163,16 @@ triangles~\cite{Botsch:2002:OPENMESH}. This redesign comes at a price
in readability of the user code; while the design of \cgalpoly\ allows
the direct traversal from item to item, i.e., direct expressions such
as
\begin{lstlisting}
facet_handle->halfedge()->opposite()->facet()
\end{lstlisting}
are possible, while in \openmesh\ the choice of an index always
requires the knowledge of the data structure itself, and potentially
more costly array arithmetic to access an item, such as in the
equivalent example now written for \openmesh
\begin{lstlisting}
hds.face_handle( hds.opposite_halfedge_handle(hds.halfedge_handle(facet_handle))).
hds.face_handle(hds.opposite_halfedge_handle(hds.halfedge_handle(facet_handle))).
\end{lstlisting}
The obvious question is, does it matter, and if, for which design. We
have a first answer in favior for the more readable \cgal\ design with
a runtime comparison of the $\sqrt{3}$ subdivision algorithm in

4
Packages/Tutorial/tutorial/Polyhedron/sgp2004/paper/remeshing.tex
View File

@ -13,7 +13,7 @@ used for remeshing. We now give some details over the software
components used for isotropic~\cite{acdi-isr-03} as well as for
anisotropic remeshing~\cite{acdld-apr-03}.
\subsection{Isotropic Remeshing}
\subsubsection{Isotropic Remeshing}
% isotropic remeshing, what for ?
@ -75,7 +75,7 @@ kernel~\cite{bbp-iayed-01,p-iaeia-99}, which gives robustness required
for complex models by mixing exact and floating point arithmetic in a
transparent manner for the programmer.
\subsection{Anisotropic Remeshing}
\subsubsection{Anisotropic Remeshing}
% anisotropic remeshing, what for ?

61
Packages/Tutorial/tutorial/Polyhedron/sgp2004/paper/subdivision.tex
View File

@ -1,31 +1,33 @@
Subdivision surfaces \cite{cc,ds,loop,sqrt3,qts}
are the limit surface resulting from the
application of a subdivision algorithm to a control mesh.
Subdivision algorithms recursively \emph{refine} (subdivide) the
control mesh and \emph{modify} (smooth) the geometry according
to a stencil on the source mesh.
Further details on subdivisions can be found at \cite{Sub:course:2000}
and \cite{Warren:subdivision}. The OpenMesh library has
supports of Loop and $\sqrt{3}$ subdivisions \cite{Abhijit:2004:APISUB}.
%Subdivision surfaces \cite{cc,ds,loop,sqrt3,qts}
%are the limit surface resulting from the
%application of a subdivision algorithm to a control mesh.
%Subdivision algorithms recursively \emph{refine} (subdivide) the
%control mesh and \emph{modify} (smooth) the geometry according
%to a stencil on the source mesh.
%Further details on subdivisions can be found at \cite{Sub:course:2000}
%and \cite{Warren:subdivision}. The OpenMesh library has
%supports of Loop and $\sqrt{3}$ subdivisions \cite{Abhijit:2004:APISUB}.
Subdivision algorithms contain two major
components: \emph{\tr} and \emph{\gm}.
The \tr\ reparameterizes the source mesh into a refined
mesh. The \gm\ transforms a submesh on the source mesh
to a vertex on the refined mesh. The source submesh (with
Subdivision algorithms \cite{Warren:subdivision, Sub:course:2000}
contain two major steps: \emph{\tr} and \emph{\gm}.
The \tr\ reparameterizes the control mesh into a refined
mesh. The \gm\ transforms a submesh on the control mesh
to a vertex on the refined mesh. The submesh (with
the normalized weights) is called the
\emph{stencil}. A proper combination of a \tr\ and a set of
rules of \gm\ define a valid subdivision scheme.
\emph{stencil}. A subdivision algorithm recursively
applies these two steps on the control mesh and generate
the limit surfaces.
%A proper combination of a \tr\ and a set of
%rules of \gm\ define a valid subdivision scheme.
Fig.\ref{fig:RefSchemes} shows the local configurations
of the major refinements
employed in subdivision algorithms, which include Catmull-Clark
The local configurartions of refinements employed in subdivision
algoruthms are shown in Fig.\ref{fig:RefSchemes}, including Catmull-Clark
subdivision (PQQ) \cite{cc}, Loop subdivision (PTQ) \cite{loop},
Doo-Sabin subdivision (DQQ) \cite{ds} and $\sqrt{3}$ subdivision
\cite{sqrt3}. Subdivisions, such as Quad-Triangle subdivision
\cite{qts,l-pg-03}, may employ a hybrid refinement consisting
of two different refinements (PQQ and PTQ).
\begin{figure}
of two different refinements.
\begin{figure}[htb]
\centering
\psfrag{PQQ}[]{\scriptsize PQQ}
\psfrag{PTQ}[]{\scriptsize PTQ}
@ -40,14 +42,11 @@ of two different refinements (PQQ and PTQ).
\label{fig:RefSchemes}
\end{figure}
The \gm\ multiplies the stencils and
generates the corresponding vertex on the refined mesh.
%The stencil usually specifies an affine map of the
%submesh.
Fig.\ref{fig:RefMap} demonstrates the examples of the
correspondence between a stencil and its vertex. According
to the employed refinement scheme, subdivisions
may have several distinct stencils
(Fig.\ref{fig:RefMap} (a-c)).
results the vertices on the refined mesh.
Examples of the correspondence between a stencil and its
vertex are shown in Fig.\ref{fig:RefMap}, where
Catmull-Clark subdivision has three distinct stencils
and Doo-Sabin subdivision has only one stencil.
\begin{figure}
\centering
\psfrag{A}[]{(a)}
@ -66,11 +65,11 @@ may have several distinct stencils
% templated rules: a generic framework for subdivisions
%\subsection{Generic Subdivisions}
\subsubsection{Generic Subdivision Solution}
%\label{sec:subtempl}
\input subtempl
\subsection{Sqrt 3}
\subsubsection{Sqrt 3}
% connectivity ops: specific polyhedron algorithms (sqrt3 subdivisions)
%\subsection{$\sqrt{3}$-Subdivision using Euler Operators}
\input sqrt3

60
Packages/Tutorial/tutorial/Polyhedron/sgp2004/paper/subtempl.tex
View File

@ -10,21 +10,20 @@ i.e.\ the stencil, attends the \gm s. By mixing and matching
the host and policy, a combinatory library of the subdivisions
is then constructed.
In the following paragraph, we implement the Catmull-Clark
In the following paragraph, we implement Catmull-Clark
subdivision and Doo-Sabin subdivision based on the
policy-based design. For the sake of simplicity, all
namespaces, template declarations
and typedefs have been excluded. The sample codes are only
and typedefs are excluded. The sample codes are only
given for illustration purposes.
A Catmull-Clark subdivision function is structured
as a \emph{primal quadralization function} parameterized
with the \emph{Catmull-Clark stencil rules}.
as a primal quadralization function parameterized
with the policies of the Catmull-Clark stencils.
\begin{lstlisting}
void CatmullClark_subdivision(Polyhedron& p) {
quadralize_polyhedron<CatmullClark_rule<Polyhedron>>(p);
}
class CatmullClark_rule {
public:
void facet_rule(Facet_handle facet, Point& pt);
@ -38,17 +37,17 @@ and the \lstinline!CatmullClark_rule!
is the policy class applying the Catmull-Clark stencils.
\lstinline!Polyhedron! is the typedef of a user-specialized
\cgalpoly . The \lstinline!quadralize_polyhedron<>()!
refines the source mesh while maintaining the
refines the control mesh while maintaining the
correspondence of the stencil, i.e.\ the submesh centered
around the given facet, edge, or
vertex, and the smoothing point. The smoothing point
is calculated by calling the policies, i.e.\
the \lstinline!facet_rule()!, the \lstinline!edge_rule()!,
and the \lstinline!vertex_rule()!.
Different refinement scheme may require a
different set of stencils. A PQQ scheme needs the
facet-, edge- and vertex-stencils whereas a DQQ scheme
only needs the corner-stencils (Fig.\ref{fig:RefMap}).
%Different refinement scheme may require a
%different set of stencils. A PQQ scheme needs the
%facet-, edge- and vertex-stencils whereas a DQQ scheme
%only needs the corner-stencils (Fig.\ref{fig:RefMap}).
\noindent\textbf{Geometry Policies}.
Inside a policy, applying stencil is simplified as
@ -76,7 +75,7 @@ Though for a specialized kernel, special computation may be
applied in the user-defined policies.
\noindent\textbf{The refinement host based on Euler operations}.
Implementing a topology refinement is a rather complex job. One
Implementing the topology refinement is a rather complex job. One
approach is to encode the refinement into \emph{a sequence of Euler
operations}. For Catmull-Clark subdivision, the refinement is encoded
as edge-vertex insertions, an edge insertion between two neighboring
@ -111,17 +110,17 @@ the stencil correspondence of the refinement.
Most primal refinement schemes can be translated into a sequence of
Euler operations. Though dual schemes, e.g.\ Doo-Sabin subdivision,
have no simple translation of Euler operations. A sequence
of Euler operations for a DQQ scheme consists of two times
of Euler operations for a DQQ scheme consist of two times
of the midedge refinement \cite{Peters:1997:SSS} and
result an inefficient implementation. This multipass
refinement scheme, called subdivision operator factorization,
is proposed in \cite{Peter:2003:CPDSS}.
is introduced in \cite{Peter:2003:CPDSS}.
To support such schemes efficiently, we use the modifier
callback mechanism of \cgalpoly\ to rebuild the mesh
connectivity. In addition to the point buffer, we
also create a facet list based on the source mesh. Note that in a DQQ
scheme, every new facet corresponds to a vertex, edge or facet. The
combination of the points buffer and facet list represents a
combination of the points buffer and facet list represent a
facet-vertex index list which indexes the vertices and enumerates each
facet as an index sequence. A modifier creating a polyhedron from a
facet-vertex index list is then a simple task.
@ -144,16 +143,16 @@ facet-vertex index list is then a simple task.
\begin{figure}
\centering
\epsfig{file=figs/plane0.eps, width=3cm} \\
\epsfig{file=figs/planeCC1.eps, width=3.5cm}
\epsfig{file=figs/planeDS1.eps, width=3.5cm}\\
\epsfig{file=figs/planeCC2.eps, width=3.5cm}
\epsfig{file=figs/planeDS2.eps, width=3.5cm}\\
\epsfig{file=figs/planeCC.eps, width=3.5cm}
\epsfig{file=figs/planeDS.eps, width=3.5cm}
\caption{Catmull-Clark subdivision surfaces (\IL) and
Doo-Sabin subdivision surfaces (\IR)
of an aircraft polyhedron (\IT).
\epsfig{file=figs/plane0.eps, width=2.35cm} \\
\epsfig{file=figs/planeCC1.eps, width=2.35cm}
\epsfig{file=figs/planeCC2.eps, width=2.35cm}
\epsfig{file=figs/planeCC.eps, width=2.35cm}\\
\epsfig{file=figs/planeDS1.eps, width=2.35cm}
\epsfig{file=figs/planeDS2.eps, width=2.35cm}
\epsfig{file=figs/planeDS.eps, width=2.35cm}
\caption{Catmull-Clark subdivision surfaces ({\itshape second row}) and
Doo-Sabin subdivision surfaces ({\itshape third row})
of an aircraft polyhedron ({\itshape first row}).
}
\label{fig:SubExample}
\end{figure}
@ -163,8 +162,8 @@ Our subdivision solution, decoupling the geometry rules from the
refinement, grants users flexible control of the stencils.
Variants of the subdivisions can be devised by simply mixing
and matching the refinement hosts and geometry policies.
A combinatory subdivision set is provided withn our subdivision
solution. It includes the Catmull-Clark subdivision, Doo-Sabin
A combinatory subdivision set is provided within our subdivision
solution. It includes Catmull-Clark subdivision, Doo-Sabin
subdivision, Loop subdivision, Quad-Triangle subdivision and
$\sqrt{3}$ subdivision. Since
\cgalpoly\ supports mesh of non-uniform configurations
@ -181,10 +180,11 @@ More importantly, our solution accepts a user-specialized
polyhedron. No special flag or attribute is required
to assist the \tr . This generality make our solution
naturally fit in a modeling pipeline or a multipass modeling
environment. In some applications, efficiency is more
important than flexibility. An efficient implementation
of $\sqrt{3}$ based on \cgalpoly\ is introduced in next
section.
environment.
%In some applications, efficiency is more
%important than flexibility. An efficient implementation
%of $\sqrt{3}$ based on \cgalpoly\ is introduced in next
%section.
%TODO: since the writing memory is not overlapped, multi-threaded
%supporting is easily done.