PolyCube-Maps

Marco Tarini Kai Hormann Paolo Cignoni Claudio Montani

Visual Computing Lab, ISTI / CNR, Pisa∗

Abstract However, we are so used to the maxim that texture mapping of

triangle meshes requires a segmentation and the existence of seams,
Standard texture mapping of real-world meshes suffers from the that we tend to forget that they are a most limiting factor. In fact, it
presence of seams that need to be introduced in order to avoid ex- is well-known that seams cause:
cessive distortions and to make the topology of the mesh compat-
ible to the one of the texture domain. In contrast, cube maps pro- • Mesh dependence: The different levels-of-detail (LOD) of a
vide a mechanism that could be used for seamless texture mapping multi-resolution model usually require an individual parame-
with low distortion, but only if the object roughly resembles a cube. terization and texture image, unless care is taken that the patch
We extend this concept to arbitrary meshes by using as texture do- boundaries coincide for all levels.
main the surface of a polycube whose shape is similar to that of • Inadequate filtering: Mip-mapping and bilinear interpolation
the given mesh. Our approach leads to a seamless texture mapping both require the texels to be contiguous, a property that is not
method that is simple enough to be implemented in currently avail- satisfied at the patch boundaries. As a consequence seams are
able graphics hardware. visible.
CR Categories: I.3.7 [Computer Graphics]: Three-Dimensional • Wasted texture memory: Even the best packing algorithms
Graphics and Realism—Color, Shading, Shadowing, and Texture; cannot avoid that some parts of the texture domain are not
I.3.1 [Computer Graphics]: Hardware Architecture—Graphics Pro- covered by a texture patch. The uncovered texels may be used
cessors to partially prevent the filtering artefact mentioned above by
adding a certain number of texels to enlarge the chart bound-
Keywords: texture mapping, u-v-mapping, atlas generation, sur- aries, but in general they do not store any information and
face parameterization, cube maps must be considered wasted.
URL: http://vcg.isti.cnr.it/polycubemaps In this paper we introduce PolyCube-Maps, a new mechanism for
superior texture mapping, that avoids the first two drawbacks and
wastes almost no texture memory. It can be seen as a generalization
1 Introduction of the well known cube map mechanism (see Section 2).
The task of texture mapping a 3D surface with colour information
from an image or with some other signal from a 2D domain is rele- 1.1 Related work
vant for many applications in computer graphics and the quality of
Most of the work on texture mapping follows the multi-chart ap-
the result depends heavily on the quality of the underlying param-
proach with varying focuses on the different aspects of a good atlas
eterization. Ideally, the parameterization should be conformal and
generation, namely partitioning, parameterization, and packing.
area-preserving so as to avoid any signal distortion, but it is well-
In order to enable parameterizations without any distortion,
known that such an isometric mapping exists only for developable
Cignoni et al. [1999] and Carr and Hart [2002] propose to let the
surfaces like cones and cylinders.
patches be composed of a single triangle or pairs of triangles, but
The standard approach for triangle meshes therefore is to cut the
this results in a highly fragmented texture space and introduces
surface into several disk-like patches each of which can be param-
seams all over the mesh. Other approaches consider larger patches
eterized with low distortion. This multi-chart or atlas approach
and try to make the parameterization per patch as conformal or area-
inevitably produces seams, in other words, the boundaries of the
preserving as possible [Maillot et al. 1993; Lévy et al. 2002; Grimm
patches need to be replicated so that there will be vertices that have
2002; Sorkine et al. 2002; Sander et al. 2003]. For more detailed
the same position in 3D but different texture coordinates in 2D.
information on parameterizations in general we refer the interested
Besides the problem of segmenting a given mesh such that the reader to the recent survey by Floater and Hormann [2004].
seams become least visible, the process of creating a good overall Multi-chart methods suffer from the fact that they produce seams
mapping also requires to define suitable boundaries of the charts with all the drawbacks mentioned above. Several authors therefore
in the 2D domain, to compute the parameterizations for each indi- suggested to cut the surface where the seam is least visible [Piponi
vidual patch, and to finally pack the texture patches efficiently into and Borshukov 2000; Lévy et al. 2002; Sheffer and Hart 2002].
a rectangular shape. Artists who manually design u-v-mappings of Moreover, seams heavily constrain the underlying geometric rep-
their models with great care, as well as automatic or semi-automatic resentation of the mesh because triangles are not allowed to cross
algorithms, strive to find the best possible solution for each of these the patch boundaries. This is a severe limitation, for example, if
steps and we have seen extremely good results even for very com- one single texture shall be used for all LODs of a multi-resolution
plex meshes in the past. model. Cohen et al. [1998] addressed this problem by construct-
∗ e-mail: ing the multi-resolution model with a constrained simplification se-
{tarini,hormann,cignoni,montani}@isti.cnr.it
quence that handles the patch boundaries appropriately and an im-
provement of this method was presented by Praun et al. [2000].
The only way to avoid having seams is to choose a texture do-
main that has both the same topology as the given mesh and a sim-
ilar shape. There exist several methods that construct a seamless
parameterization of a mesh over a triangulated base complex [Eck
et al. 1995; Lee et al. 1998; Khodakovsky et al. 2003; Praun and
Hoppe 2003] and use it for remeshing and mesh compression.
R3 T3

X T3 X T2
Figure 2: A polycube that consists of 10 cubes (left) and the parti-
Figure 1: Cube maps can be used to seamlessly texture map an ap- tion of its surface into cells as explained in Section 3 (right).
ple (left). In this case, the 3D texture domain T3 is the surface of
a single cube that is immersed in the 3D texture space T3 (mid- X T2
dle) and corresponds to a 2D texture domain T2 that consists of six
square images (right).  T3
XX 3
T XX
1.2 Overview
In principle, these seamless parameterization methods could also be
used for texture mapping. Colour information could be defined on
the domain triangles of the base complex and the parameter values Figure 3: The 2D analogue of our method: the projection P maps
of the mesh vertices could be used to linearly map the colour to the each point (or fragment) in T3 onto the 3D texture domain T3 (left).
mesh triangles. However, difficulties arise when the vertices of a The mapping M can then be used to look up the texture information
mesh triangle have parameter values on different domain triangles from the 2D texture domain T2 . PolyCube-Maps are not tied to the
and their linear interpolation is a secant triangle that falls outside mesh structure and work for different mesh representations (right).
the surface on which the colour information is defined.
Our approach is similar to the idea that we just sketched, but in-
stead of using a triangulated base complex we use the surface of a vT 3 = (vr , vs , vt ) ∈ T3 . At rendering time, the vertices and their 3D
polycube as texture domain. The special structure of this surface texture positions are fed to the graphics pipeline and the rasterizer
not only allows to efficiently store and access the colour informa- interpolates the latter ones to get a 3D texture position fI3 for ev-
tion in a standard 2D texture, but also to handle the problem of ery produced fragment f and passes it on to the fragment shader.
secant triangles by simply projecting them onto the texture domain. Even if all 3D texture positions vT 3 lie on T3 , this is not necessar-
Both this projection and the colour access are simple enough to ily the case for the interpolated 3D texture position fI3 . Therefore,
be implemented in currently available graphics hardware. As a re- the fragment shader applies a projection P : T3 → T3 to map fI3
sult we have a new seamless texture mapping technique. But let us to a point fT 3 in the 3D texture domain. It further uses a second
start by explaining the basic idea behind our PolyCube-Maps which mapping M : T3 → T2 to determine the colour information at fT 3
stems from the concept of cube maps. that is stored in the 2D texture domain T2 (see Figure 3 for the 2D
analogue). In our case, T2 is one single rectangular texture image
2 PolyCube-Maps with a packing of several square patches.
The most important feature of PolyCube-Maps is that the 3D
Cube maps are commonly used for environment mapping, but they texture coordinates vary continuously over the surface of the object
can also be used to define a seamless texture mapping for, say, an and therefore enable a seamless texture mapping even though the
apple (see Figure 1). In fact, all we need to do is to assign to each texture information itself is stored as a collection of square images.
vertex of such a 3D model a 3D texture position (which can differ
from the vertex position). We call the space of possible texture posi-
tions the 3D texture space and denote it by T3 to distinguish it from
3 How PolyCube-Maps Work
the object space R3 that contains the vertex positions. The cube Let us now explain in detail how we define the functions P and M .
map mechanism will then use a simple central projection to project Remember that we want to use PolyCube-Maps for the purpose of
the texture position of every rendered fragment onto the surface of texture mapping and both P and M must be computed in the frag-
a unitary cube with its centre at the origin. Let us call the surface of ment shader which is the tighter sub-loop of the graphics pipeline.
this cube the 3D texture domain and denote it by T3 with T3 ⊂ T3 . Therefore their implementation must be as simple and quick as pos-
The cube map mechanism will further associate each point of T3 sible. To achieve this, we define both mappings piecewise over an
with a position in a 2D texture space, which in this case is a col- adequate partition of T3 .
lection of six planar square texture images, one for each face of
the cube. We denote this 2D texture domain by T2 . The resulting
mapping will be seamless and will avoid all the drawbacks that we
sketched in the introduction. However, this use of cube maps is
fairly uncommon because it works only for quasi-spheres and our
main idea is to extend this concept to more general shapes.
For our PolyCube-Maps we use as 3D texture domain T3 the
surface of a polycube rather than a single cube. A polycube is a
shape composed of axis-aligned unit cubes that are attached face
to face (see Figure 2, left). In order to get the best results, the used Figure 4: Another 2D analogue: we roughly approximate the object
polycube should very roughly resemble the shape of the given mesh surface with a polycube (left), consider the dual space of unit cubes
and capture the large scale features. centered in the corners of the polycube (middle), and finally have
Once the polycube is defined, we proceed as follows. First we for each non-empty cube a projection function that assigns each
assign to each vertex v of the mesh a unique 3D texture position point inside a cube to the polycube surface (right).
 type 3 type 4a type 4b type 5 type 6a type 6b

Figure 5: Six basic configurations can occur (up to rotations and reflections) in a non-empty cell. Top: sub-part of the polycube surface T3
inside the cell with different colours for the individual facelets. Centre: projection lines of P inside the cell; they are orthogonal to the shown
surfaces. Bottom: packing of squarelets into patches; the colour of the squarelets corresponds to the colour of the associated facelet.

We subdivide the 3D texture space T3 into cubic cells that are

equal in size and orientation to the cubes that the polycube is com-
posed of, but we offset these cells by 0.5 in each direction such that
the vertices of the polycube lie at their centres (see Figure 4 for the
2D analogue). We chose this dual partition because of the following
advantages:

1. it is still easy to determine in which cell a point in T3 lies,

2. the number of different configurations that can occur in the
cells which intersect with the surface of the polycube is lim-
ited to a small number,
3. for each of these configurations it is possible to define the
functions P and M piecewise inside each cell and still make
them continuous at the faces of the cells,
4. these functions P and M are simple to compute. Figure 6: A simple PolyCube-Map example for the apple model of
Figure 1. The polycube is subdivided into eight cells of type 3 but
3.1 Cell configurations each with a different rotation. Each cell contains three facelets that
are stored as a set of three texture squarelets.
We now consider the intersection of the cells with the polycube
surface T3 and remark that it naturally subdivides the faces of the
polycube into four facelets. There are 63 different configurations and (1, 1, 1) then the projection direction of vT 3 for the first four
of facelets that can occur inside a cell which intersects with the configurations is given by
polycube since we only consider polycubes with a two-manifold
surface. These configurations can be further reduced down to the type 3 type 4a type 4b type 5
six basic configurations in Figure 5 if we take out rotational and ( r − r, 1 − s, 1 − t), if s ≥ r
reflectional similarities. Each cell contains between three and six (r, s,t) (r, 0,t) (0, 0, 1) s
(1 − r, rs − s, 1 − t), if s < r
facelets. For example, the polycube that consists of a single cube
is decomposed into eight cells containing three facelets each (see The formulas for the other two cases are slightly more compli-
Figure 6). More complex examples are shown in Figures 2 and 11 cated but since we did not use them in our implementation (see
where the colour coding refers to the basic configuration and the Section 5.2) we omit them for the sake of brevity.
facelets inside each cell are separated by thin white lines. A nice property of the so-defined projections is that they partition
the interior of the cell into (infinitely many) non-intersecting lines
3.2 The projection P such that all points on each of these lines are projected to the same
point on T3 . Furthermore, the projection lines of two neighbouring
For each of the basic configurations we can now define the projec- cells are identical on the common face and hence the projection
tion P that maps points in T3 onto T3 by specifying the projection is globally continuous. The central row in Figure 5 gives an idea
direction at any point vT 3 = (vr , vs , vt ) inside the cell. If we assume how the projections for the six basic configurations look like and an
without loss of generality that the coordinates are between (0, 0, 0) example of the 2D analogue is shown on the right of Figure 4.
3.3 The mapping M To make T3LUT a random access table, we also include all the
empty cells in the bounding box of the polycube. However, the
Conceptually, all colour information that we use for texture map- look-up table is still very small as a polycube typically consists of
ping is defined on the 3D texture domain T3 , i.e. on the facelets of only a small number of cubes. In the examples that we show in this
the polycube. We could store the colour information as a 3D tex- paper, T3LUT is always smaller than one Kilo texel, whereas the final
ture, but since most of the voxels would be empty, this option is by texture T2 can be several Mega texels.
far too wasteful. Instead, we use a technique similar to the one that If a model has multiple associated textures (e.g. a colour map, a
is used by cube maps. normal map, and a specular coefficient map) then the textures can
Each facelet in T3 is a square region and the mapping M maps all share the same PolyCube-Map and they can be accessed through
this region to a corresponding squarelet in the 2D texture domain the same T3LUT .
T2 . Our squarelets consist of S×S texels where the size S is a user-
specified parameter that must be chosen as a power of two.
All the squarelets for the facelets in one cell are packed together 5 Fragment Shader Program
in a larger rectangular texture patch as shown in the bottom row of
Figure 5. Due to the shape of the texture patches, they can easily Each fragment that enters the fragment shader with a 3D texture po-
be packed into T2 and the position of, for example, the upper left sition fI3 ∈ T3 will undergo the fragment program that is described
corner can be stored as a global 2D offset for each particular cell. by the following pseudo-code:
The local offsets to the individual squarelets inside the texture patch
do not need to be stored as they are fixed for each of the six basic 1. compute the 3D index i ∈ N3 of the cell that contains fI3 by
configurations. i =  fI3 + (0.5, 0.5, 0.5) and the subcell position fs = fI3 − i
Thus, applying the mapping M to a point p ∈ T3 inside a cell with fs ∈ [−0.5, +0.5)3 ,
consists of three steps. First, the relative position of p inside the
containing facelet is determined and multiplied with S to give the 2. fetch the entry e from the texture T3LUT at index i,
relative position in the corresponding squarelet. Then the result is 3. rotate fs around the origin by e.R (see Section 5.1),
offset according to the fixed packing of the squarelets inside the 4. apply the projection P and the mapping M (without the
texture patch and finally, the global offset of that patch in T2 is global offset) as defined for case e.C (see Section 5.2),
added.
Both the local and the global offset are a multiple of S. This 5. add the global offset e.O,
means that subsequent mip-map levels will merge together only 6. use the result as an index to access the final texel value in the
texels coming from the same squarelet and that each squarelet is 2D texture T2 (see Section 5.3).
represented by a single pixel on the coarsest mip-map level log2 (S).
Note that the index i must first be serialized in the second step if the
look-up table T3LUT is kept in a tiny subpart of the 2D texture T2 .
4 The 3D Look-up Table Furthermore, if a model has multiple associated textures, then the
last access is repeated for each texture using the same coordinate.
The polycube must be adapted to the shape of the mesh that is to A similar texturing approach that utilizes a 3D look-up table in
be textured and therefore we need a flexible way for the application order to access information relative to a sub-volume of the space
that uses PolyCube-Maps to specify the polycube. Our solution is has also been used in the totally different context of compressing
to store the cell-structure of T3 in a 3D look-up table T3LUT and volumetric datasets [Schneider and Westermann 2003].
define each cell through a set of parameters in the corresponding An optimized implementation of this algorithm in OpenGL ARB
entry of T3LUT . This look-up table must be kept in texture memory Fragment Program language is just 54 instructions long, leaving
so that it can be accessed by the fragment shader. It can either be enough resources to implement other effects (e.g. shading). If a
stored as a small 3D texture or, in order to reduce the number of complex fragment program needs to access several textures in order
rendering-time state variables, it can be serialized and physically to compute the final colour values, then the 54 instructions overhead
kept in a subpart of T2 . is paid only once since all textures share the same PolyCube-Map.
When processing a fragment f , the fragment shader first deter-
mines the cell that contains the fragment’s interpolated 3D texture
position fI3 . A single texture access to T3LUT at the correspond- 5.1 Storing and applying rotations
ing entry returns all the parameters needed to compute P and M We store the rotation e.R that is applied in the third step of the
which are then used to find the final 2D texture position fT 2 ∈ T2 . algorithm above in a special way that is not only space-efficient but
Each entry of T3LUT is packed in one (r, g, b)-texel, so that it can also allows to unpack and apply the rotation with few operations.
be fetched with a single texture read instruction. More precisely, an Any of the 24 possible axis-to-axis rotations can be coded in a
entry e is composed of three parts: C, R, and O, where series of 5 bits where each bit decides whether the corresponding
• e.C is the index of one of the six basic cell configurations, operation of the following ordered list is to be performed or not:
• e.R is the index of one of the 24 axis-to-axis rotations, 1. (r, s,t) → (−t, −s, −r)
• e.O is the global offset of the patch corresponding to e in T2 . 2. (r, s,t) → (s,t, r)
3. (r, s,t) → (s,t, r)
The rotation e.R maps each axis into another axis in the positive or
negative direction and is used to transform the given cell into the 4. (r, s,t) → (−r, −s,t)
default orientation of the configuration e.C shown in Figure 5. If 5. (r, s,t) → (r, −s, −t)
there are several different rotations that achieve this, any of them
can be chosen. Each operation can be implemented with a single extended swizzle
While the values e.C and e.R are packed together in a single byte, command plus a conditional assignment that stores or discards the
e.O requires two bytes, one for each coordinate. These coordinates result (according to the value of the corresponding bit in e.R).
are expressed in multiples of S so that 8 bits are sufficient to store The current fragment shader languages do not support bit-wise
them. operations, but the value of the i-th bit of e.R can be extracted by
a sequence of supported operations: multiply by 2−(i+1) , take the (a) (b) (c) R3
fractional part, subtract 0.5, and finally check positivity. Vector
operations can be used to recover four boolean values in parallel.

5.2 Applying the basic cases

M project
After the rotation, the fragment shader computes the projection P
and the mapping M , both at one go. Although these functions are

p –1
p
defined differently for the basic cases and it would be sufficient to

ar

ar
w

w
execute only the code that implements the case e.C, we cannot do
this because the shading languages lack a general branching con- T3 optimize
struct. Instead we compute all cases in sequence and use a condi-
tional assignment at the end of each case to record only the result
of case e.C in a register.
Since all cases are computed anyway, it is profitable to identify
common subexpressions that are shared by different branches so
as to reduce the number of overall instructions. Actually, we took T3 (d) (e) (f)
care of maximizing the number of common subexpressions, when Figure 7: The 2D analogue of our technique to assign 3D texture
we decided on the default orientation of the basic cases and the positions to the vertices of a mesh (a): we first warp the poly-
packing of squarelets into patches. cube (d) close to the mesh (b), then we project the vertices in the
A side effect of this non-branched architecture is that the cost of normal direction onto the warped polycube surface (c), warp the re-
processing a fragment depends on the total number of instructions sult back (e), and finally optimize the texture positions. The meshes
needed to cover all basic cases. Moreover, the cases 6a and 6b in the top row are in R3 while those in the bottom row are in T3 .
are the most complex and the least beneficial, as they hardly ever
occur in useful polycubes. And since their implementation in the
fragment shader would have burdened the execution for all the other 6.1 Construction of the poly-cubic parameterization
cases as well, we decided to leave them out of our implementation.
This choice implies a limitation on the polycube layout, but when The first step is to assign to every vertex v of the given mesh M a
we constructed polycubes for real-world meshes (see Section 6) we 3D texture position vT 3 ∈ T3 . As we have seen in Section 2, this can
found the practical effect of this limitation to be negligible. be done by a simple central projection if the mesh has a sphere-like
shape and T3 is a surrounding cube. For more complex meshes we
propose the following procedure that is illustrated in Figure 7.
5.3 Filtering and mip-mapping We start by defining a polycube that has roughly the same shape
as M and captures all the large scale features. For example, the
When the final texel value is fetched from T2 in the last step of polycube for the bunny has two stacks of 4 cubes that resemble the
the algorithm, the mip-mapping mechanism still works (including ears, a 3×3×4 block for the head, and so on (see Figure 10).
the linear interpolation between different mip-map levels), because Next we warp the surface T3 of the polycube from its axis-
the size and the positions of squarelets are both powers of 2. The aligned position in the 3D texture space T3 to the object space R3 .
only difference with respect to the default is that the mip-map level We manually move its vertices close to the mesh and take care that
selection must be set so that it is based on the speed of the texture the large scale features of the warped polycube surface and those
positions fI3 in T3 , rather than the final texture position in T2 . of the mesh are roughly aligned. For some meshes a simple scal-
In contrast, bilinear interpolation cannot be performed as usual, ing, rotation, and translation of the polycube surface can serve as a
because the interpolation would mix texels that belong to different warp function. For example, this was the case for the Laurana and
squarelets whenever the border of a squarelet is accessed. However, the 3-holes object (see Figure 10).
we can still run the code multiple times and manually interpolate the Then we establish a correspondence between both surfaces by
fetched texels in the fragment shader. In this way, bilinear interpo- moving every vertex v of M along the surface normal direction onto
lation can be performed without adding any texels at squarelet bor- the deformed polycube. This projection may generate fold-overs,
ders, because the fragment shader “knows” about the patch bound- mostly in regions with small scale features, but before we attend
aries. This method requires to turn off the automatic bilinear inter- to this matter, we apply the inverse warp function to the projected
polation, which can be done in current fragment languages as they vertices and map them to T3 .
explicitly allow this kind of “do-it-yourself” interpolation. These initial 3D texture positions vT 3 usually do not define a
The complete scheme costs 4·54 instructions for computing the good parameterization, in other words, the piecewise linear func-
2D texture positions plus 4 for the texture fetches and 3 for the bi- tion that maps each triangle of M to the corresponding parameter
linear interpolation itself. But it is possible to compromise between triangle in T3 deforms the shape of the triangles considerably and
quality and efficiency by using an anti-aliasing schemes that ac- may not even be one-to-one in some parts. We therefore imple-
cesses and interpolates a smaller number of texels. Of course, each mented a simple iterative procedure to optimize the texture posi-
texture fetch can be mip-mapped automatically. tions and to minimize the overall distortion of the parameterization.
For each vertex v we consider the local mapping between the
one-ring of v in M and the one-ring of vT 3 in T3 . Then we compute
6 Construction of a PolyCube-Map the gradient of the deformation energy of the local mapping with
respect to vT 3 and a simple one-dimensional line-search along this
So far we described the mechanism of PolyCube-Maps and we direction gives us a new position vT 3 . If the one-ring of vT 3 is
will now sketch a method that can be used for the construction of not flat, then vT 3 may not lie on T3 and we use the projection P
a PolyCube-Map for a given triangle mesh. We used this semi- to map it back onto T3 in that case. By iterating over the vertices
automatic technique to produce all the examples that are shown in and applying these local optimizations, we successively improve
this paper. the quality of the poly-cubic parameterization globally.
 projection mean value MIPS extended MIPS

Figure 8: Optimizing the initial parameterization that we created by

projection (left) using different techniques: the mean value coordi-
nates and the MIPS method (middle) tend to produce conformal Figure 9: The packing of texture patches is almost perfect and it can
maps at the expense of global area distortion, while the extended be seen that triangles are allowed to span across multiple squarelets.
MIPS method (right) nicely balances angle and area deformations.

In our experiments we tested three different deformation ener-

gies and Figure 8 shows a comparison of the results. The first one
is based on the mean value coordinates [Floater 2003] and has the
advantage of leading to a linear local optimization problem. This
method has also been used in [Khodakovsky et al. 2003] and tends
to give conformal parameterizations. The same holds for the non-
linear MIPS energy [Hormann and Greiner 2000] but both results
are not well-suited for our purposes as the area deformation can be
quite large. We therefore prefer to use an extension of the MIPS
method that was presented by Degener et al. [2003]. It allows
to mediate between the conformality and the area-preservation of
the parameterization by choosing a weighting parameter θ and we
found θ = 3 to give very good results in all our examples. For more
detailed information on parameterizations we refer the interested
reader to the recent survey by Floater and Hormann [2004].

6.2 Construction of the look-up table

Once the polycube has been specified, the construction of T3LUT is
simple. For each cell that contains a vertex of the polycube we
assign the basic case e.C and a rotation e.R to the corresponding
entry e in T3LUT . Both are fully determined by the arrangement of
the eight cubes incident to that vertex and we can easily precompute
the 63 possible configurations that can occur around the vertices of
a two-manifold polycube surface.
We further assign the global offset e.O for all non-empty cells,
thus defining the global packing of the texture patches inside T2 .
Even very simple heuristics deal well with this simple packing.
For example, we can iteratively assign patches to the first avail-
able place, scanning T2 from left to right and from top to bottom
(see Figures 9 and 12).
Of course, we cannot guarantee to cover the entire 2N ×2M tex-
ture space T2 , but this is a minor problem. Whenever we need to
keep textures for multiple models in the texture memory, they can
be packed in the same global texture map so that only a small frac-
tion of texture space will be left unused in the end.

7 Experimental Results
To test the potential of PolyCube-Maps, we produced a few exam-
ples (see Figures 10 and 12) with the method described in Section 6.
The texel values of the texture map T2 have been filled using either
a regular pattern or the shading of the mesh at highest resolution
as in [Cignoni et al. 1999]. Note that our method is not limited to Figure 10: Examples of models with poly-cubic parameterizations:
closed surfaces. In fact, the Laurana model is open at the bottom the original model (left), using the PolyCube-Map to texture it with
and we can still use PolyCube-Maps as long as the polycube surface a regular grid (middle), and shaded parameterization of the mesh
is open at the bottom, too (see Figure 11). over the polycube surface (right).
Figure 11: Our method also allows to handle open meshes as
long as the polycube captures this feature and is open, too. The
facelets of the polycube and the corresponding parts on the mesh
are coloured according to the cell configuration.

distortion stretch efficiency

area angle T3 → M M → T3 [Gu] [Praun]
3-holes 1.003 1.011 0.986 0.986
Laurana 1.141 1.101 0.795 0.745
bunny 1.034 1.069 0.892 0.913 0.639 0.703
armadillo 1.224 1.318 0.616 0.577 0.607 0.465

Table 1: Distortion of the poly-cubic parameterizations φ from Fig-

ure 10. Area and angle distortions are measured by integrating and
normalizing the values σ1 σ2 + 1/(σ1 σ2 ) and σ1 /σ2 + σ2 /σ1 , re-
spectively, where σ1 and σ2 are the singular values of the Jaco-
bian matrix Jφ (see [Degener et al. 2003] and [Floater and Hormann
2004] for details). The stretch efficiency is computed as in [Praun
and Hoppe 2003]. For all measures, the optimal value is 1.

Table 1 lists several distortion measures that document the qual-

ity of the underlying poly-cubic parameterizations and compares it
with the results of Gu et al. [2002] and Praun and Hoppe [2003].
It can be seen that using a polycube surface as parameterization
domain instead of a flat domain (Gu et al. use a square) or sim-
ple spherical shapes (Praun and Hoppe use platonic solids) helps
to reduce the overall distortion. This is not surprising because the
polycube has a shape similar to that of the mesh.

Mesh independence. We can also apply a single PolyCube-

Map to several simplified versions of a given mesh as shown in
Figure 12. A key property of our method is that the simplification
of the original mesh does not have to take the PolyCube-Map into
account and vice versa. In other words, none of the atomic simpli-
fication operations (e.g. edge collapse) has to be forbidden because Figure 12: A single PolyCube-Map can be used to texture map dif-
of the texture parameterization, and on the other hand, the definition ferent simplified versions (top) with the shading of the given mesh
of the texture T2 and the look-up table T3LUT are both independent or a regular pattern (middle). The corresponding poly-cubic param-
of the simplification process. eterizations and the texture T2 are shown at the bottom.
Apart from such simplified versions, the same PolyCube-Map
would also work with other models that share the general shape of
the original one, including multi-resolution structures and remeshes 8 Conclusions and Discussion
(even quadrilateral ones), as long as an appropriate 3D texture po-
sition is defined for every vertex (see Figure 3). In our example we PolyCube-Maps provide a new mechanism for texture mapping
assigned to each vertex of the simplified meshes the 3D texture po- general 3D meshes. Once an appropriate polycube is chosen and
sition of the closest point (in the normal direction) on the surface of a poly-cubic parameterization of the given mesh over the polycube
the original model which in turn is defined by linear interpolation surface is computed, it can be used to seamlessly map colour or
of the texture coordinates at the corners of the containing triangle. other signals onto that mesh and other models with a similar shape.
If each squarelet is considered a chart, then a PolyCube-Map
Rendering performance. Texture mapping with PolyCube- can be seen as a multi-chart method, but with one important differ-
Maps can slow down a fill-limited application because of the longer ence. Although the final 2D texture coordinates, if seen as a func-
fragment shader required. Still we never experienced the frame rate tion that is defined over the mesh surface, are discontinuous at the
to drop below 30 fps with mip-mapping and without bilinear inter- chart boundaries, these discontinuities are not visible because the
polation or 10 fps with both turned on, even when most of the screen underlying 3D texture coordinates are continuous. And since they
was covered. Tests were performed with an nVIDIA GeForce FX are dealt with on a per-fragment basis that is hidden from the user,
5600 and an ATI Radeon 9800 Pro on a Pentium 4 with 2.4 Ghz. PolyCube-Maps have all the advantages of a seamless mapping that
were discussed in the introduction, including mip-mapping. More- Acknowledgements
over, PolyCube-Maps are mesh independent and the packing of tex-
ture patches is trivial because of their simple rectangular shape and This work was supported by the projects ViHAP3D (EU IST-2001-
it causes almost no wasted texture space. 32641) and MACROGeo (FIRB-MIUR RBAU01MZJ5) and by the
Deutsche Forschungsgemeinschaft (DFG HO 2457/1-1).

8.1 Limits of PolyCube-Maps References

Obviously, PolyCube-Maps also have limits in the scope of their
C ARR , N. A., AND H ART, J. C. 2002. Meshed atlases for real-time proce-
applicability. If the geometry or topology of a mesh is too complex dural solid texturing. ACM Transactions on Graphics 21, 2, 106–131.
or has features at very different scales, then an appropriate polycube
C IGNONI , P., M ONTANI , C., ROCCHINI , C., S COPIGNO , R., AND
would consist of so many cubes that the size of the corresponding
TARINI , M. 1999. Preserving attribute values on simplified meshes
T3LUT would soon exceed the texture memory. An extreme example
by resampling detail textures. The Visual Computer 15, 10, 519–539.
would be a model of a tree with trunk, branches, and leaves.
C OHEN , J., O LANO , M., AND M ANOCHA , D. 1998. Appearance-
In Section 7 we showed that a single PolyCube-Map can be used
preserving simplification. In Proc. of ACM SIGGRAPH 98, 115–122.
for texture mapping different representations of the same object.
However, if such a representation deviates too much from the origi- C OHEN , M. F., S HADE , J., H ILLER , S., AND D EUSSEN , O. 2003. Wang
Tiles for image and texture generation. ACM Transactions on Graphics
nal mesh for which the PolyCube-Map was constructed, then it can
22, 3, 287–294.
happen that the texture position of a produced fragment falls in an
empty cell, which results in a visible rendering artefact. D EGENER , P., M ESETH , J., AND K LEIN , R. 2003. An adaptable surface
parameterization method. In Proc. of the 12th International Meshing
Roundtable, 201–213.
8.2 Geometry images E CK , M., D E ROSE , T., D UCHAMP, T., H OPPE , H., L OUNSBERY, M.,
AND S TUETZLE , W. 1995. Multiresolution analysis of arbitrary meshes.
PolyCube-Maps represent a special type of parameterization that In Proc. of ACM SIGGRAPH 95, 173–182.
has been designed for texture mapping, but it can also be used for F LOATER , M. S., AND H ORMANN , K. 2004. Surface parameterization: a
remeshing and storing purposes, becoming a variant of geometry tutorial and survey. In Advances in Multiresolution for Geometric Mod-
images [Gu et al. 2002]. Each final texel in T2 can be used to store elling, N. A. Dodgson, M. S. Floater, and M. A. Sabin, Eds. Springer,
a sample of the mesh by mapping the coordinates (x, y, z) to the 259–284.
(r, g, b) channels. The pair of textures T2 and T3LUT can then be F LOATER , M. S. 2003. Mean value coordinates. Computer Aided Geomet-
seen as a stand-alone representation of the original model. ric Design 20, 1, 19–27.
In particular, each squarelet in T2 would encode a subpart of the G RIMM , C. M. 2002. Simple manifolds for surface modeling and parame-
encoded surface with a trivially defined connectivity (each group of terization. In Proc. of Shape Modeling International 2002, 237–244.
four adjacent texels forms a quad). The information that is stored G U , X., G ORTLER , S. J., AND H OPPE , H. 2002. Geometry images. ACM
in T3LUT would then be used to zipper the subparts into a single co- Transactions on Graphics 21, 3, 355–361.
herent mesh. This would be easy because the sides of neighbouring H ORMANN , K., AND G REINER , G. 2000. MIPS: An efficient global
subparts have the same number of points. parametrization method. In Curve and Surface Design: Saint-Malo
1999, P.-J. Laurent, P. Sablonnière, and L. L. Schumaker, Eds. Vanderbilt
University Press, 153–162.
8.3 Future work K HODAKOVSKY, A., L ITKE , N., AND S CHR ÖDER , P. 2003. Globally
Extensions. As soon as the GPU programmability has advanced smooth parameterizations with low distortion. ACM Transactions on
so that the number of fragment program instructions is less critical, Graphics 22, 3, 350–357.
it will be possible to include the cell cases that we left out of the cur- L EE , A. W. F., S WELDENS , W., S CHR ÖDER , P., C OWSAR , L., AND
rent implementation. Any two-manifold polycube surface can then D OBKIN , D. 1998. MAPS: multiresolution adaptive parameterization
be used as 3D texture domain T3 . Another useful extension would of surfaces. In Proc. of ACM SIGGRAPH 98, 95–104.
be some hierarchical approach (e.g. with octrees) for the subdivi- L ÉVY, B., P ETITJEAN , S., R AY, N., AND M AILLOT, J. 2002. Least
sion of the texture space T3 , taking care not to require too many squares conformal maps for automatic texture atlas generation. ACM
additional accesses to the 3D look-up table T3LUT . Transactions on Graphics 21, 3, 362–371.
M AILLOT, J., YAHIA , H., AND V ERROUST, A. 1993. Interactive texture
mapping. In Proc. of ACM SIGGRAPH 93, 27–34.
Tiled textures. PolyCube-Maps have the potential for a new P IPONI , D., AND B ORSHUKOV, G. 2000. Seamless texture mapping of
type of tiled textures. For each cell configuration we could cre- subdivision surfaces by model pelting and texture blending. In Proc. of
ate and store 2D texture patches with matching boundaries, and the ACM SIGGRAPH 2000, 471–478.
3D look-up table would then be used to seamlessly map them onto P RAUN , E., AND H OPPE , H. 2003. Spherical parametrization and remesh-
the polycube surface in a sort of two-manifold Wang Tiles scheme ing. ACM Transactions on Graphics 22, 3, 340–349.
[Cohen et al. 2003]. The result would be similar to lapped textures P RAUN , E., F INKELSTEIN , A., AND H OPPE , H. 2000. Lapped textures.
[Praun et al. 2000] but without the need to use a resampled texture In Proc. of ACM SIGGRAPH 2000, 465–470.
atlas or to render triangles multiple times with alpha blending.
S ANDER , P., W OOD , Z., G ORTLER , S. J., S NYDER , J., AND H OPPE ,
H. 2003. Multi-chart geometry images. In Proc. of the Symposium on
Automatic parameterization. We believe that this work opens Geometry Processing 2003, 146–155.
the way to a new category of surface parameterization methods that S CHNEIDER , J., AND W ESTERMANN , R. 2003. Compression domain
parameterize a mesh over a polycube surface instead of a flat do- volume rendering. In Proc. of Visualization 2003, 293–300.
main or a coarse simplicial complex. The most challenging part S HEFFER , A., AND H ART, J. C. 2002. Seamster: inconspicuous low-
will be to determine appropriate polycubes with minimal or no user distortion texture seam layout. In Proc. of Visualization 2002, 291–298.
intervention, but also adapting existing parameterization methods S ORKINE , O., C OHEN -O R , D., G OLDENTHAL , R., AND L ISCHINSKI , D.
to this new kind of domain as well as speeding them up with hier- 2002. Bounded-distortion piecewise mesh parameterization. In Proc. of
archical methods will be a worthwhile task. Visualization 2002, 355–362.