mirror of https://github.com/CGAL/cgal
561 lines
23 KiB
TeX
561 lines
23 KiB
TeX
\documentclass[twocolumn]{article}
|
|
\usepackage{tutorial}
|
|
%\usepackage{a4}
|
|
|
|
\oddsidemargin 0.15 in
|
|
\marginparwidth 1 in % Width of marginal notes.
|
|
% Note that \oddsidemargin = \evensidemargin
|
|
\oddsidemargin 0in % Left margin on odd-numbered pages.
|
|
\evensidemargin 0in % Left margin on even-numbered pages.
|
|
\marginparwidth 0.75in
|
|
\textwidth 157mm % Width of text line.
|
|
% 1in top margin and 1in bottom margin
|
|
\headsep0cm
|
|
\headheight0cm
|
|
\topmargin-17.4mm
|
|
\textheight247mm % A4
|
|
\parindent 8pt
|
|
\parskip0pt
|
|
|
|
\usepackage[OT1]{fontenc}
|
|
|
|
% ------------------------------------------------------------------------
|
|
\usepackage{graphicx}
|
|
\usepackage{subfigure}
|
|
\usepackage{epsfig}
|
|
\usepackage{psfrag}
|
|
% used to write c++ code/algorithms
|
|
\usepackage{listings}
|
|
\usepackage{fancyvrb}
|
|
\usepackage{path}
|
|
|
|
%\psdraft
|
|
|
|
\twocolumn
|
|
|
|
|
|
% hyperref stuff
|
|
\usepackage{hyperref}
|
|
\hypersetup{
|
|
pdftitle={A Tutorial on CGAL Polyhedron for Subdivision Algorithms},
|
|
pdfauthor={INRIA Geometrica},
|
|
pdfsubject={A tutorial for CGAL},
|
|
pdfkeywords={},
|
|
pdfpagemode=UseThumbs,
|
|
baseurl={http://www.cgal.org},
|
|
colorlinks=true,
|
|
linkcolor=black,
|
|
anchorcolor=black,
|
|
citecolor=black,
|
|
filecolor=black,
|
|
menucolor=black,
|
|
pagecolor=black,
|
|
urlcolor=blue,
|
|
bookmarksopen=false,}
|
|
% end hyperref stuff
|
|
|
|
\lstset{language=C++, basicstyle=\scriptsize}
|
|
|
|
\input{tutorial.def}
|
|
|
|
% =========================================================================
|
|
\begin{document}
|
|
|
|
% TITLE
|
|
% ------------------------------------------------------------------------
|
|
\date{}
|
|
\title{{\LARGE {\sffamily\bfseries A Tutorial on CGAL Polyhedron \\
|
|
for Subdivision Algorithms\thanks{%
|
|
Partially supported by the grant NSF 9457806-CCR and
|
|
IST Programme of the EU as a Shared-cost
|
|
RTD (FET Open) Project under Contract No IST-2000-26473 (ECG -
|
|
Effective Computational Geometry for Curves and Surfaces).
|
|
}}}}
|
|
|
|
|
|
\author{\small
|
|
\sffamily Le-Jeng Shiue\footnote{SurfLab, University of Florida}
|
|
\and \small
|
|
\sffamily Pierre Alliez\footnote{GEOMETRICA, INRIA Sophia-Antipolis}
|
|
\and \small
|
|
\sffamily Radu Ursu\footnote{Geometry Factory, Sophia-Antipolis}
|
|
\and \small
|
|
\sffamily Lutz Kettner\footnote{Max-Planck-Institut f\"ur Informatik,
|
|
Saarbr\"ucken, Germany}}
|
|
\maketitle
|
|
|
|
\thispagestyle{empty}
|
|
|
|
\begin{abstract}
|
|
We give an overview of the tutorial for the \texttt{CGAL:: Polyhedron\_3}
|
|
and its use in subdivision algorithms. The full tutorial and the
|
|
accompanying source code are available at
|
|
\path|http://www.cgal.org/Tutorials/Polyhedron/|.
|
|
\end{abstract}
|
|
|
|
|
|
% ------------------------------------------------------------------------
|
|
\section*{Introduction}
|
|
|
|
Polyhedron data structures based on the concept of halfedges have been
|
|
very successful for the design of general algorithms on meshes.
|
|
Common practice is to develop such data structure from scratch, since
|
|
clearly a first implementation is at the level of a students homework
|
|
assignment. But then, these data 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
|
|
it, is a respectable software task.
|
|
|
|
What is common practice for simple data structures, such as linked
|
|
lists, should be common practice even more so for mesh data
|
|
structures, namely, to use a good, flexible, and efficient library
|
|
implementation. In \CC\, the \emph{Standard Template Library}, \stl,
|
|
is an excellent address for our analog example of the linked
|
|
lists~\cite{Austern:1999:GPS}, and we argue in the full tutorial that
|
|
the Polyhedron data structure in \cgal\ is such a flexible mesh data
|
|
structure~\cite{k-ugpdd-99}, and it comes with a rich and versatile
|
|
infrastructure for mesh algorithms. \cgal, the
|
|
\emph{Computational Geometry Algorithms Library}, is a
|
|
\CC\ library available from \path|www.cgal.org|~\cite{fgkss-dccga-00}.
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\includegraphics[width=\linewidth]{figs/teaser}
|
|
\caption{The polyhedron viewer running on Windows. A coarse polygon
|
|
mesh is subdivided using the quad-triangle subdivision scheme.}
|
|
\label{fig:viewer}
|
|
\end{figure}
|
|
|
|
We strongly believe that such a tutorial with its wealth of
|
|
information will give a head start to new researches 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
|
|
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
|
|
expandable in a research prototype.
|
|
|
|
The tutorial is organized around subdivision surfaces in a
|
|
polyhedron viewer. The polyhedron viewer
|
|
(\figurename\ \ref{fig:viewer}) demonstrates the basic functionalities of
|
|
the \cgalpoly\ and some extended functionalities such as file I/O,
|
|
mesh superimposition, and trackball manipulation. Several subdivision
|
|
surfaces are supported in the polyhedron viewer, including
|
|
Catmull-Clark, Loop, Doo-Sabin, $\sqrt{3}$ and Quad-Triangle
|
|
subdivisions. The tutorial shows how to implement subdivision
|
|
surfaces in two different mechanisms provided by \cgalpoly :
|
|
\emph{Euler operators} and \emph{modifier callback mechanism}. A
|
|
$\sqrt{3}$ subdivision implementation is designed based on the Euler
|
|
operators and a Quad-Triangle subdivision implementation is designed
|
|
based on overloading the modifier. Extended from the previous design,
|
|
a \emph{combinatorial subdivision library} (CSL) is then proposed with
|
|
increased sophistication and abstraction. CSL abstracts the geometry
|
|
operations from the refinements. Subdivisions in CSL are build from
|
|
refinement host with a template geometry policy. Several fundamental
|
|
refinement schemes are provided within CSL. They are instantiated with a
|
|
geometry policy that can be user defined.
|
|
|
|
The goal of this tutorial is to show how to use \cgalpoly\
|
|
on basic graphics functionalities, such as rendering and
|
|
interactive trackball manipulation, \emph{and} how to design and
|
|
implement algorithms around meshes. Since connectivity and
|
|
geometry operations are the primal implementation components
|
|
in mesh algorithms, subdivisions are chosen to
|
|
demonstrate both operations on \cgalpoly .
|
|
Readers intended to design and implement
|
|
mesh algorithms other than subdivisions will also be
|
|
benefited from the tutorial.
|
|
|
|
% ------------------------------------------------------------------------
|
|
\subsection*{Intended Audience}
|
|
|
|
The intended audience of the tutorial are researchers, developers or
|
|
students developing algorithms around polyhedron meshes. Knowledge of
|
|
the halfedge data structure and subdivisions are prerequisites.
|
|
Short introductions of these two topics are given in the tutorial.
|
|
The tutorial assumes familiarity with the \CC\ template mechanism
|
|
and the key concepts of generic programming~\cite{Austern:1999:GPS}.
|
|
|
|
|
|
% ------------------------------------------------------------------------
|
|
\subsection*{CGAL Polyhedron}
|
|
|
|
CGAL Polyhedron (\cgalpoly) is realized as a container class
|
|
that manages geometry items such as vertices, halfedges, and
|
|
facets with their incidences. \cgalpoly\ has chosen the
|
|
halfedge data structure as the underlying connectivity
|
|
structure. In the halfedge data structure, a halfedge is
|
|
associated with a facet and stores the adjacency pointers
|
|
to it previous, next and opposite halfedge (\figurename\ \ref{fig:halfedge}).
|
|
The details of the halfedge data structure and the \cgalpoly\ based
|
|
on it are described in~\cite{k-ugpdd-99}.
|
|
|
|
\begin{figure}[h]
|
|
\centering{\includegraphics[width=5.0cm]{figs/halfedge}}
|
|
\caption{One halfedge and its incident primitives. The next
|
|
halfedge, the opposite halfedge, and the incident vertex are
|
|
mandatory, the remaining elements are optional.
|
|
}
|
|
\label{fig:halfedge}
|
|
\end{figure}
|
|
|
|
What are the potential obstacles in using CGAL and \cgalpoly?
|
|
\begin{enumerate}
|
|
\item
|
|
Is it fast enough? Yes. \cgal, coming from the field of Computational
|
|
Geometry, might have a reputation of using slow exact arithmetic
|
|
to be on the safe side, but nonetheless, we know where to apply
|
|
the right techniques of exact arithmetic to gain robustness and
|
|
yet not to loose efficiency. In addition, \cgal\ uses
|
|
\emph{generic programming\/} and \emph{compile-time
|
|
polymorphism\/} to realize flexibility without affecting optimal
|
|
runtime.
|
|
\item
|
|
Is it small enough? Yes. \CodeFmt{CGAL::Polyhedron \_3} can be
|
|
tailored to store exactly the required incidences and other
|
|
required data, not more and not less.
|
|
\item
|
|
Is it flexible enough? Yes, 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.
|
|
\item
|
|
Is it easy enough to use? Yes. The full tutorial with its example
|
|
programs are exactly the starting point for using \cgalpoly. The
|
|
example programs are short and easy to understand. There is
|
|
certainly a learning curve for mastering \CC\ to the level
|
|
of using templates, but it has to be emphasized that
|
|
using templates is far easier then developing templated code.
|
|
\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
|
|
licenses. Other options are available.
|
|
\end{enumerate}
|
|
|
|
% ------------------------------------------------------------------------
|
|
\subsection*{Subdivision Surfaces}
|
|
|
|
A subdivision algorithm recursively
|
|
applies \emph{refinement} and \emph{geometry smoothing}
|
|
on the control mesh (\figurename\ \ref{fig:sqrt3},
|
|
\ref{fig:quad-triangle}),
|
|
and approximates the limit surface of the control mesh. Several
|
|
refinement schemes in practice are illustrated in
|
|
\figurename\ \ref{fig:RefSchemes}. The stencils of the
|
|
geometry smoothing are depending on the refinement schemes,
|
|
i.e.\ the reparameterizations. A stencil defines a control
|
|
submesh that is associated with normalized weights of the
|
|
nodes. \figurename\ \ref{fig:RefMap}
|
|
demonstrates the stencils of the PQQ scheme
|
|
in Catmull-Clark subdivision \cite{cc} and DQQ scheme in Doo-Sabin
|
|
subdivision \cite{ds}. We also demonstrate Loop \cite{loop},
|
|
$\sqrt{3}$ \cite{sqrt3} and Quad-Triangle \cite{qts} subdivisions
|
|
in this tutorial. For further details about subdivisions, readers
|
|
should refer to \cite{Warren:subdivision} and \cite{Sub:course:2000}.
|
|
|
|
\begin{figure}[tb]
|
|
\centering
|
|
\psfrag{PQQ}[]{\scriptsize PQQ}
|
|
\psfrag{PTQ}[]{\scriptsize PTQ}
|
|
\psfrag{DQQ}[]{\scriptsize DQQ}
|
|
\psfrag{Sqrt3}[]{\scriptsize $\sqrt{3}$}
|
|
\epsfig{file=figs/RefSchemes.eps, width=7.5cm}
|
|
\caption{Examples of refinement schemes:
|
|
primal quadrilateral quadrisection (PQQ),
|
|
primal triangle quadrisection (PTQ),
|
|
dual quadrilateral quadrisection (DQQ) and
|
|
$\sqrt{3}$ triangulation. The control meshes are shown
|
|
in the first row.}
|
|
\label{fig:RefSchemes}
|
|
\end{figure}
|
|
|
|
% ------------------------------------------------------------------------
|
|
%\section*{(Our) FAQs}
|
|
|
|
%We compile a list of questions concerned about the tutorial and the
|
|
%accompanying source codes and libraray.
|
|
|
|
|
|
%\begin{itemize}
|
|
|
|
%% \item Why should I read this tutorial? I am not interested in subdivisions.
|
|
%% The goal of this tutorial is to show how to use \cgalpoly\
|
|
%% on basic graphics functionalities, such as rendering and
|
|
%% interactive trackball manipulation, \emph{and} how to design and
|
|
%% implement algorithms around meshes. Subdivisions are choosen for their
|
|
%% connectivity and geometry operations. These two operations are the
|
|
%% primal components in most mesh algorithms. For reader not interested
|
|
%% in subdivisions, the know-how of the connectivity and geometry
|
|
%% manipulations is the foundation of mesh algorithm implementations
|
|
%% based on \cgalpoly .
|
|
|
|
%% \item Why do you use \cgal\ polyhedron? How about OpenMesh and its
|
|
%% subdivision library?
|
|
%% \cgal\ is highly generic and well-tested robust. \cgal\
|
|
%% and versatile for its geometry
|
|
%% functionalities. The OpenMesh subdivision
|
|
%% library is not as generic.
|
|
|
|
%\item Is is difficult or what's the difficulties to use \cgal\ Polyhedron?
|
|
% It is not, once you buy the concepts taken or inspired from
|
|
% the STL (iterators, circulars). You also have to be familiar
|
|
% with the concept of handles and halfedges.
|
|
|
|
%\item How about the performance?
|
|
% as fast as other libraries (and sometimes faster). It also
|
|
% scales well.
|
|
|
|
%\item I don't like the subdivisions you have, how can I build my own
|
|
% subdivision on your solution?
|
|
% depending on the level of genericity you are targeting, the
|
|
% type of scheme and whether you want to store all levels of subdivision
|
|
% in memory, choose either Euler operators, incremental builder
|
|
% or one new template rule to be plugged into the CSL.
|
|
|
|
%\item What's the future plan for CSL?
|
|
% CGAL Package?
|
|
% referenced from Warren's web site about subdivision?
|
|
|
|
%\item The viewer is based on OpenGL. Can I learn from it
|
|
% to write my own viewer based on another graphics library?
|
|
|
|
%\item What could be improved in the Polyhedron?
|
|
% built-in functions for # of boundaries, # of connected
|
|
% components and genus.
|
|
% edge collapses without the currently too restrictive precondition
|
|
% (along with a function bool is_collapsible(Halfedge_handle h)
|
|
% based on e.g. Edelsbrunner criteria.
|
|
% built-in function bool is_border(Vertex_handle v)
|
|
% built-in function to know the type of mesh (e.g. pure tri,
|
|
% pure quad, tri-quad or polygonal).
|
|
|
|
%\end{itemize}
|
|
|
|
% ------------------------------------------------------------------------
|
|
\section*{Tutorial Outlines}
|
|
|
|
% ------------------------------------------------------------------------
|
|
\subsection*{Polyhedron Viewer}
|
|
|
|
%% We have designed and implemented an application based on the
|
|
%% \cgalpoly. This program provides a polyhedron viewer of
|
|
%% following functionalities:\\
|
|
%% \indent $\bullet$ File I/O,\\
|
|
%% \indent $\bullet$ polyhedron rendering,\\
|
|
%% \indent $\bullet$ and trackball manipulation.\\
|
|
%% In addition to these built-in functions, the viewer is accompanied
|
|
%% with a set of subdivision algorithms that generate smooth polyhedron
|
|
%% surfaces from a coarse polyhedron. \italic{The tutorial instructs the
|
|
%% readers through the design and the implementation of the polyhedron
|
|
%% viewer and the subdivisions}. The first part of the tutorial
|
|
%% highlights the design and implementation issues related to the \poly\
|
|
%% used in the viewer. The second part of the tutorial explains how to
|
|
%% implement the connectivity and geometry operations of the subdivision
|
|
%% algorithms. The source codes are going to be published with the
|
|
%% releasing of the tutorial.
|
|
|
|
The tutorial starts with an implementation of
|
|
a basic polyhedron viewer based on the \cgalpoly\ with the
|
|
default configuration.
|
|
This basic viewer demonstrates basic functionalities of a
|
|
\cgalpoly . We describe how to import a polyhedron file in
|
|
the OFF format based on the \italic{modifier callback mechanism} and the
|
|
\italic{incremental builder}. We also show the mesh traversal based on
|
|
the \italic{iterators} and the \italic{circulators} for rendering and
|
|
the OFF file exporting.
|
|
|
|
An extended polyhedron viewer is then introduced by customizing
|
|
the \poly\ with extra attributes and functionalities. This
|
|
enriched polyhedron supports facet and vertex normals for rendering,
|
|
supports the axis-aligned bounding box of the polyhedron, and
|
|
provides geometry items specialized with algorithmic flags.
|
|
%The extended primitives are employed to support efficient
|
|
%computation of the number of connected components, number
|
|
%of boundaries and combinatorial genus of the polyhedron.
|
|
The superimposition of the control mesh on the subdivision surfaces
|
|
are implemented with the flags of the halfedge items
|
|
(\figurename\ \ref{fig:quad-triangle}).
|
|
%This enriched polyhedron is used as
|
|
%the core data structure of our application.
|
|
|
|
The tutorial also features a trackball to interactively manipulate the
|
|
polyhedron, a snapshot function of the camera viewpoint and
|
|
the transformation states, a raster output to the clipboard, and the
|
|
vectorial output to a postscript file.% (\figure\ \ref{fig:gargoyle}).
|
|
|
|
\begin{figure}[h]
|
|
\centering
|
|
\psfrag{A}[]{(a)}
|
|
\psfrag{B}[]{(b)}
|
|
\psfrag{C}[]{(c)}
|
|
\psfrag{D}[]{(d)}
|
|
\epsfig{file=figs/RefMap.eps, width=7.5cm}
|
|
\caption{The stencil ({\itshape top blue}) and its
|
|
vertex ({\itshape bottom red}) in
|
|
Catmull-Clark subdivision (a-c)
|
|
and Doo-Sabin subdivision (d). Catmull-Clark
|
|
subdivision has three stencils: facet-stencil (a),
|
|
edge-stencil (b) and vertex-stencil (c).
|
|
Doo-Sabin subdivision has only corner-stencil (d).
|
|
The stencil weights are not shown.}
|
|
\label{fig:RefMap}
|
|
\end{figure}
|
|
|
|
%% \begin{figure}[t]
|
|
%% \centering{\includegraphics[width=3.5cm]{figs/gargoyle_raster}
|
|
%% \includegraphics[width=3.5cm]{figs/gargoyle_vec}}
|
|
%% \caption{Raster and vectorial output of the gargoyle mesh.}
|
|
%% \label{fig:gargoyle}
|
|
%% \end{figure}
|
|
|
|
% ------------------------------------------------------------------------
|
|
\subsection*{Subdivision Algorithms}
|
|
|
|
The second part of the tutorial focuses on the design and the
|
|
implementation of $\sqrt{3}$ subdivision (\figurename\ \ref{fig:sqrt3})
|
|
and Quad-Triangle subdivision (\figurename\ \ref{fig:quad-triangle}).
|
|
|
|
In addition to its importance in the surface modeling, we
|
|
choose subdivision algorithms to demonstrate both the
|
|
\italic{connectivity operation} (refinement) and the
|
|
\italic{geometry operation} (smoothing) of a
|
|
\cgalpoly . These two operations are the
|
|
primary implementation components required by algorithms on
|
|
polyhedron meshes. Readers intended to design and implement
|
|
mesh algorithms other than subdivisions will also be benefited
|
|
from the techniques we proposed here.
|
|
|
|
The key to implement a subdivision algorithm is to
|
|
efficiently support the refinement, i.e.\ the connectivity
|
|
modifications. Two approaches are introduced to support the
|
|
refinement: the \italic{Euler operators} (operator scheme) and
|
|
the \italic{modifier callback mechanism} (modifier scheme).
|
|
The operator scheme reconfigures the connectivity with a
|
|
combination of Euler operators. $\sqrt{3}$ subdivision~\cite{sqrt3} is
|
|
used to demonstrate this scheme. We also compare our implementation
|
|
with the $\sqrt{3}$ subdivision provided in OpenMesh library.
|
|
|
|
Though simple and efficient in some
|
|
refinements, e.g.\ $\sqrt{3}$ subdivision, the correct combination of
|
|
the operators is hard to find for some refinements, e.g.\ Doo-Sabin
|
|
subdivision~\cite{ds}. The modifier scheme solves the problem by
|
|
letting the programmers create their own combinatorial operators
|
|
using the polyhedron incremental builder. Quad-Triangle
|
|
subdivision~\cite{qts,l-pg-03} is used to demonstrate this scheme.
|
|
|
|
% ------------------------------------------------------------------------
|
|
\subsection*{Combinatorial Subdivision Library}
|
|
|
|
The \emph{C}ombinatorial \emph{S}ubdivision \emph{L}ibrary
|
|
(CSL) is designed based on the policy-based design
|
|
\cite{Alexandrescu:2001:MCD}.
|
|
The policy-based design assembles a class
|
|
(called \emph{host}) with complex behavior out of many
|
|
small behaviors (called \emph{policies}).
|
|
Each policy defines an interface for a
|
|
specific behavior. CSL proposes a
|
|
generic subdivision solution as a \emph{refinement function}
|
|
parameterized with the \emph{geometry smoothing rules}.
|
|
Subdivisions in CSL are build as proper combinations of the
|
|
refinement functions and the geometry policy classes.
|
|
The refinement function refines the control mesh,
|
|
maintains the correspondence between the control mesh and refined
|
|
mesh, and applies the smoothing stencils provided by the policy
|
|
class. For example, Catmull-Clark subdivision~\cite{cc} is structured
|
|
\begin{figure}[h]
|
|
\centering{\includegraphics[width=7.0cm]{figs/sqrt3}}
|
|
\caption{$\sqrt{3}$ subdivision of the mannequin mesh.}
|
|
\label{fig:sqrt3}
|
|
\vspace{0.5cm}
|
|
\end{figure}
|
|
as a quadralization function parameterized with the Catmull-Clark
|
|
smoothing rules.
|
|
|
|
|
|
\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);
|
|
void edge_rule(Halfedge_handle edge, Point& pt);
|
|
void vertex_rule(Vertex_handle vertex, Point& pt);
|
|
};
|
|
\end{lstlisting}
|
|
\noindent The \CodeFmt{quadralize\_polyhedron<>()}
|
|
is the host function refining the input mesh
|
|
and the \CodeFmt{CatmullClark\_rule} is the policy
|
|
class applying the Catmull-Clark stencils.
|
|
The refinement functions are implemented based on the
|
|
Euler operations or the modifier callback mechanism.
|
|
The refinement functions also maintain the
|
|
correspondence with 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, e.g., the \CodeFmt{facet\_rule()}, the
|
|
\CodeFmt{edge\_rule()}, and the \CodeFmt{vertex\_rule()}
|
|
respectively. Inside a policy, applying the
|
|
stencil is simplified to the mesh traversal of a
|
|
1-ring neighborhood which can be done with the
|
|
circulators. Following example illustrates
|
|
the policy of the facet-stencil in Catmull-Clark
|
|
subdivision.
|
|
\begin{lstlisting}
|
|
void facet_rule(Facet_handle facet, Point& point) {
|
|
Halfedge_around_facet_circulator hcir
|
|
= facet->facet_begin();
|
|
Vector vec = hcir->vertex()->point() - ORIGIN;
|
|
++hcir;
|
|
do {
|
|
vec = vec + hcir->vertex()->point();
|
|
} while (++hcir != facet->facet_begin());
|
|
point = ORIGIN + vec/circulator_size(hcir);
|
|
}
|
|
\end{lstlisting}
|
|
|
|
\begin{figure}[h]
|
|
\centering{\includegraphics[width=7.5cm]{figs/quad-triangle}}
|
|
\caption{Quad-Triangle subdivision of the rhombicuboctahedron mesh.}
|
|
\label{fig:quad-triangle}
|
|
\end{figure}
|
|
|
|
This policy-based approach offers a convenient way to
|
|
specialize a subdivision with the template smoothing rules.
|
|
CSL currently supports Catmull-Clark,
|
|
Loop, Doo-Sabin, $\sqrt{3}$ and Quad-Triangle
|
|
subdivisions. %(\figurename\ \ref{fig:subzoo}).
|
|
Though demonstrated with a specific enriched \poly\ in our
|
|
polyhedron viewer, CSL accepts any polyhedron mesh specialized
|
|
from the \poly\ with the \CodeFmt{Point} type defined in the vertex.
|
|
%not just the enriched polyhedron we used in the polyhedron
|
|
%viewer.
|
|
|
|
%% \begin{figure}[tb]
|
|
%% \centering
|
|
%% % \epsfig{file=figs/rook.eps, width=2cm}
|
|
%% \epsfig{file=figs/rook_cc.eps, width=1.3cm}
|
|
%% \epsfig{file=figs/rook_ds.eps, width=1.3cm}
|
|
%% \epsfig{file=figs/rook_qt.eps, width=1.3cm}
|
|
%% \epsfig{file=figs/rook_loop.eps, width=1.3cm}
|
|
%% \epsfig{file=figs/rook_sqrt3.eps, width=1.3cm}
|
|
%% \caption{Subdivisions supported in CSL.}
|
|
%% \label{fig:subzoo}
|
|
%% \end{figure}
|
|
|
|
|
|
% references
|
|
{\footnotesize
|
|
\bibliographystyle{alpha}
|
|
\bibliography{abstract}
|
|
}
|
|
|
|
\end{document}
|