\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}
