A Tutorial on CGAL Polyhedronfor Subdivision Algorithms∗

Le-Jeng Shiue† Pierre Alliez‡ Radu Ursu§ Lutz Kettner¶

Abstract

We give an overview of the tutorial for the CGAL::Polyhedron 3 and its use in subdivision algo-rithms. The full tutorial and the accompanyingsource code are available at http://www.cgal.org/Tutorials/Polyhedron/.

Introduction

Polyhedron data structures based on the concept ofhalfedges have been very successful for the designof general algorithms on meshes. Common prac-tice is to develop such data structure from scratch,since clearly a first implementation is at the level ofa students homework assignment. But then, thesedata structures consist almost entirely of pointers forall sort of incidence informations. Maintaining themconsistently during mesh operations is not anymore atrivial linked-list update operation. So, moving froma students exercise to a reliable research implemen-tation, including maintaining and optimizing it, is arespectable software task.

What is common practice for simple data struc-tures, such as linked lists, should be common prac-tice even more so for mesh data structures, namely,to use a good, flexible, and efficient library imple-mentation. In C++ the Standard Template Library,STL, is an excellent address for our analog exampleof the linked lists [Aus99], and we argue in the fulltutorial that the Polyhedron data structure in CGAL

is such a flexible mesh data structure [Ket99], andit comes with a rich and versatile infrastructure formesh algorithms. CGAL, the Computational Geom-etry Algorithms Library, is a C++ library availablefrom www.cgal.org [FGK+00].

We strongly believe that such a tutorial with itswealth of information will give a head start to newresearches and implementations of mesh algorithms.We also believe that it will raise the quality of im-plementations. Firstly, it encourages the use of well

∗Partially supported by the grant NSF 9457806-CCR and ISTProgramme of the EU as a Shared-cost RTD (FET Open) Projectunder Contract No IST-2000-26473 (ECG - Effective Computa-tional Geometry for Curves and Surfaces).

†SurfLab, University of Florida‡GEOMETRICA, INRIA Sophia-Antipolis§Geometry Factory, Sophia-Antipolis¶Max-Planck-Institut fur Informatik, Saarbrucken, Germany

Figure 1 – The polyhedron viewer running on Win-dows. A coarse polygon mesh is subdivided usingthe quad-triangle subdivision scheme.

tested and over time matured implementations, e.g.,CGAL::Polyhedron 3 in its current design is aboutfive years publicly released and used. Secondly, itdocuments good implementation choices, e.g., theexample programs can be used as starting pointsfor evolutionary software development. Thirdly, itoffers easy access to additional functionality, suchas the efficient self intersection test, that otherwisecould be expandable in a research prototype.

The tutorial is organized around subdivision sur-faces in a polyhedron viewer. The polyhedronviewer (Figure 1) demonstrates the basic function-alities of the CGAL::Polyhedron 3 and some ex-tended functionalities such as file I/O, mesh su-perimposition, and trackball manipulation. Severalsubdivision surfaces are supported in the polyhe-dron viewer, including Catmull-Clark, Loop, Doo-Sabin,

√3 and Quad-Triangle subdivisions. The

tutorial shows how to implement subdivision sur-faces in two different mechanisms provided byCGAL::Polyhedron 3: Euler operators and mod-ifier callback mechanism. A

√3 subdivision im-

plementation is designed based on the Euler oper-ators and a Quad-Triangle subdivision implemen-

tation is designed based on overloading the modi-fier. Extended from the previous design, a combi-natorial subdivision library (CSL) is then proposedwith increased sophistication and abstraction. CSLabstracts the geometry operations from the refine-ments. Subdivisions in CSL are build from refine-ment host with a template geometry policy. Sev-eral fundamental refinement schemes are providedwithin CSL. They are instantiated with a geometrypolicy that can be user defined.

The goal of this tutorial is to show how to useCGAL::Polyhedron 3 on basic graphics function-alities, such as rendering and interactive track-ball manipulation, and how to design and imple-ment algorithms around meshes. Since connectiv-ity and geometry operations are the primal imple-mentation components in mesh algorithms, subdivi-sions are chosen to demonstrate both operations onCGAL::Polyhedron 3. Readers intended to designand implement mesh algorithms other than subdivi-sions will also be benefited from the tutorial.

Intended Audience

The intended audience of the tutorial are researchers,developers or students developing algorithms aroundpolyhedron meshes. Knowledge of the halfedge datastructure and subdivisions are prerequisites. Shortintroductions of these two topics are given in the tu-torial. The tutorial assumes familiarity with the C++template mechanism and the key concepts of genericprogramming [Aus99].

CGAL Polyhedron

CGAL Polyhedron (CGAL::Polyhedron 3) is re-alized as a container class that manages geometryitems such as vertices, halfedges, and facets withtheir incidences. CGAL::Polyhedron 3 has chosenthe halfedge data structure as the underlying con-nectivity structure. In the halfedge data structure,a halfedge is associated with a facet and stores theadjacency pointers to it previous, next and oppositehalfedge (Figure 2). The details of the halfedge datastructure and the CGAL::Polyhedron 3 based on itare described in [Ket99].

Figure 2 – One halfedge and its incident primitives.The next halfedge, the opposite halfedge, and the in-cident vertex are mandatory, the remaining elementsare optional.

What are the potential obstacles in using CGALand CGAL::Polyhedron 3?

1. Is it fast enough? Yes. CGAL, coming fromthe field of Computational Geometry, mighthave a reputation of using slow exact arith-metic to be on the safe side, but nonetheless,we know where to apply the right techniquesof exact arithmetic to gain robustness and yetnot to loose efficiency. In addition, CGAL usesgeneric programming and compile-time poly-morphism to realize flexibility without affectingoptimal runtime.

2. Is it small enough? Yes. CGAL::Polyhedron3 can be tailored to store exactly the required

incidences and other required data, not moreand not less.

3. Is it flexible enough? Yes, certainly withinits design space of oriented 2-manifold mesheswith boundary that was sufficient for the rangeof applications illustrated with our exampleprograms.

4. Is it easy enough to use? Yes. The full tuto-rial with its example programs are exactly thestarting point for using CGAL::Polyhedron 3.The example programs are short and easy to un-derstand. There is certainly a learning curve formastering C++ to the level of using templates,but it has to be emphasized that using templatesis far easier then developing templated code.

5. What is the license, can I use it? Yes, we hopeso. CGAL since release 3.0 and our tutorial pro-grams have open source licenses. Other optionsare available.

Subdivision Surfaces

A subdivision algorithm recursively applies refine-ment and geometry smoothing on the control mesh(Figure 5, 6), and approximates the limit surface ofthe control mesh. Several refinement schemes inpractice are illustrated in Figure 3. The stencils ofthe geometry smoothing are depending on the refine-ment schemes, i.e. the reparameterizations. A stencildefines a control submesh that is associated with nor-malized weights of the nodes. Figure 4 demonstratesthe stencils of the PQQ scheme in Catmull-Clarksubdivision [CC78] and DQQ scheme in Doo-Sabinsubdivision [DS78]. We also demonstrate Loop[Loo94],

√3 [Kob00] and Quad-Triangle [SL03]

subdivisions in this tutorial. For further details aboutsubdivisions, readers should refer to [WW02] and[ZS00].

PSfrag replacements

PQQ PTQ DQQ√

3

Figure 3 – Examples of refinement schemes: primalquadrilateral quadrisection (PQQ), primal trianglequadrisection (PTQ), dual quadrilateral quadrisec-tion (DQQ) and

√3 triangulation. The control

meshes are shown in the first row.

Tutorial Outlines

Polyhedron Viewer

The tutorial starts with an implementationof a basic polyhedron viewer based on theCGAL::Polyhedron 3 with the default config-uration. This basic viewer demonstrates basicfunctionalities of a CGAL::Polyhedron 3. Wedescribe how to import a polyhedron file in the OFFformat based on the modifier callback mechanismand the incremental builder. We also show the meshtraversal based on the iterators and the circulatorsfor rendering and the OFF file exporting.

An extended polyhedron viewer is then introducedby customizing the Polyhedron 3 with extra at-tributes and functionalities. This enriched polyhe-dron supports facet and vertex normals for render-ing, supports the axis-aligned bounding box of thepolyhedron, and provides geometry items special-ized with algorithmic flags. The superimposition ofthe control mesh on the subdivision surfaces are im-plemented with the flags of the halfedge items (Fig-ure 6).

The tutorial also features a trackball to interac-tively manipulate the polyhedron, a snapshot func-tion of the camera viewpoint and the transformationstates, a raster output to the clipboard, and the vecto-rial output to a postscript file.

Subdivision Algorithms

The second part of the tutorial focuses on the designand the implementation of

√3 subdivision (Figure 5)

and Quad-Triangle subdivision (Figure 6).In addition to its importance in the surface

modeling, we choose subdivision algorithms todemonstrate both the connectivity operation (refine-ment) and the geometry operation (smoothing) of aCGAL::Polyhedron 3. These two operations arethe primary implementation components required byalgorithms on polyhedron meshes. Readers intendedto design and implement mesh algorithms other than

PSfrag replacements

(a) (b) (c) (d)

Figure 4 – The stencil (top blue) and its vertex (bot-tom red) in Catmull-Clark subdivision (a-c) andDoo-Sabin subdivision (d). Catmull-Clark subdivi-sion has three stencils: facet-stencil (a), edge-stencil(b) and vertex-stencil (c). Doo-Sabin subdivision hasonly corner-stencil (d). The stencil weights are notshown.

subdivisions will also be benefited from the tech-niques we proposed here.

The key to implement a subdivision algorithm isto efficiently support the refinement, i.e. the connec-tivity modifications. Two approaches are introducedto support the refinement: the Euler operators (op-erator scheme) and the modifier callback mechanism(modifier scheme). The operator scheme reconfig-ures the connectivity with a combination of Euler op-erators.

√3 subdivision [Kob00] is used to demon-

strate this scheme. We also compare our implemen-tation with the

√3 subdivision provided in Open-

Mesh library.Though simple and efficient in some refinements,

e.g.√

3 subdivision, the correct combination ofthe operators is hard to find for some refinements,e.g. Doo-Sabin subdivision [DS78]. The modifierscheme solves the problem by letting the program-mers create their own combinatorial operators usingthe polyhedron incremental builder. Quad-Trianglesubdivision [SL03, Lev03] is used to demonstratethis scheme.

Combinatorial Subdivision Library

The Combinatorial Subdivision Library (CSL) is de-signed based on the policy-based design [Ale01].The policy-based design assembles a class (calledhost) with complex behavior out of many small be-haviors (called policies). Each policy defines aninterface for a specific behavior. CSL proposes ageneric subdivision solution as a refinement functionparameterized with the geometry smoothing rules.Subdivisions in CSL are build as proper combina-tions of the refinement functions and the geometrypolicy classes. The refinement function refines thecontrol mesh, maintains the correspondence betweenthe control mesh and refined mesh, and applies thesmoothing stencils provided by the policy class.For example, Catmull-Clark subdivision [CC78] isstructured as a quadralization function parameter-

Figure 5 –√

3 subdivision of the mannequin mesh.

ized with the Catmull-Clark smoothing rules.void C a t m u l l C l a r k s u b d i v i s i o n ( P o l y h e d r o n & p ) {

q u a d r a l i z e p o l y h e d r o n<C a t m u l l C l a r k r u l e <Polyhedron >>(p ) ;

}c l a s s C a t m u l l C l a r k r u l e {p u b l i c :

void f a c e t r u l e ( F a c e t h a n d l e f a c e t , P o i n t & p t ) ;void e d g e r u l e ( H a l f e d g e h a n d l e edge , P o i n t & p t ) ;void v e r t e x r u l e ( V e r t e x h a n d l e v e r t e x , P o i n t & p t ) ;

} ;

The quadralize polyhedron<>() is the hostfunction refining the input mesh and the Cat-

mullClark rule is the policy class applying theCatmull-Clark stencils. The refinement functionsare implemented based on the Euler operations orthe modifier callback mechanism. The refinementfunctions also maintain the correspondence with thestencil, i.e., the submesh centered around the givenfacet, edge, or vertex, and the smoothing point. Thesmoothing point is calculated by calling the policies,e.g., the facet rule(), the edge rule(), and thevertex rule() respectively. Inside a policy, ap-plying the stencil is simplified to the mesh traversalof a 1-ring neighborhood which can be done with thecirculators. Following example illustrates the policyof the facet-stencil in Catmull-Clark subdivision.void f a c e t r u l e ( F a c e t h a n d l e f a c e t , P o i n t & p o i n t ) {

H a l f e d g e a r o u n d f a c e t c i r c u l a t o r h c i r= f a c e t−>f a c e t b e g i n ( ) ;

V e c t o r vec = h c i r−>v e r t e x ()−> p o i n t ( ) − ORIGIN ;++ h c i r ;do {

vec = vec + h c i r−>v e r t e x ()−> p o i n t ( ) ;} whi le ( + + h c i r ! = f a c e t−>f a c e t b e g i n ( ) ) ;p o i n t = ORIGIN + vec / c i r c u l a t o r s i z e ( h c i r ) ;

}

This policy-based approach offers a convenientway to specialize a subdivision with the templatesmoothing rules. CSL currently supports Catmull-Clark, Loop, Doo-Sabin,

√3 and Quad-Triangle

subdivisions. Though demonstrated with a specificenriched Polyhedron 3 in our polyhedron viewer,CSL accepts any polyhedron mesh specialized fromthe Polyhedron 3 with the Point type defined in

Figure 6 – Quad-Triangle subdivision of the rhom-bicuboctahedron mesh.

the vertex.

References[Ale01] Andrei Alexandrescu. Modern C++ Design:

Generic Programming and Design Patterns Applied.Addison-Wesley, 2001.

[Aus99] Matthew H. Austern. Generic programming and theSTL: using and extending the C++ Standard Tem-plate Library. Addison-Wessley, 1999.

[CC78] E. Catmull and J. Clark. Recursively generatedB-spline surfaces on arbitrary topological meshes.Computer-Aided Design, 10:350–355, September1978.

[DS78] D. Doo and M. Sabin. Behaviour of recursive divi-sion surfaces near extraordinary points. Computer-Aided Design, 10:356–360, September 1978.

[FGK+00] A. Fabri, G.-J. Giezeman, L. Kettner, S. Schirra, andS. Schonherr. On the Design of CGAL, a Computa-tional Geometry Algorithms Library. Softw. – Pract.Exp., 30(11):1167–1202, 2000.

[Ket99] L. Kettner. Using generic programming for design-ing a data structure for polyhedral surfaces. Comput.Geom. Theory Appl., 13:65–90, 1999.

[Kob00] L. Kobbelt.√

3-Subdivision. In Proceedings of SIG-GRAPH, pages 103–112, 2000.

[Lev03] A. Levin. Polynomial generation and quasi-interpolation in stationary non-uniform subdivision.Compu. Aided Geom. Des., 20(1):41–60, 2003.

[Loo94] C. Loop. Smooth spline surfaces over irregularmeshes. In Proceedings of SIGGRAPH, pages 303–310, 1994.

[SL03] J. Stam and C. Loop. Quad/triangle subdivision.Computer Graphics Forum, 22(1):79–85, March2003.

[WW02] J. Warren and H. Weimer. Subdivision Methods forGeometric Design. Morgan Kaufmann, 2002.

[ZS00] D. Zorin and P. Schroder, editors. Subdivision forModeling and Animation, Course Notes. ACM SIG-GRAPH, 2000.