Robust Repair of Polygonal Models

Tao Ju∗
Rice University

Figure 1: A synthetically distorted Horse model (left) containing numerous self-intersecting polygons, gaps and holes, and the repaired model
(right) with a closed surface.

Abstract 2 compares two groups of curve models in 2D, one group being
closed (bottom) and the other not (top).
We present a robust method for repairing arbitrary polygon mod- We seek a robust method for repairing an arbitrary polygonal
els. The method is guaranteed to produce a closed surface that model, so that the repaired model is always closed. Due to the
partitions the space into disjoint internal and external volumes. diversity and complexity of polygonal models, mesh repair faces
Given any model represented as a polygon soup, we construct an daunting challenges. Specifically, an ideal repair method should
inside/outside volume using an octree grid, and reconstruct the sur- possess the following properties:
face by contouring. Our novel algorithm can efficiently process
large models containing millions of polygons and is capable of re- 1. Robustness: The method should always produce a closed sur-
producing sharp features in the original geometry. face for any input model.
CR Categories: I.3.5 [Computer Graphics]: Computational Ge-
ometry and Object Modeling—Boundary representations; Curve, 2. Efficiency: The method should be able to process huge mod-
surface, solid, and object representations; Geometric algorithms, els within reasonable time and space.
languages, and systems
3. Accuracy: The method should preserve the geometry of the
Keywords: model repair, robustness, scan conversion, octree input model whenever possible.

1 Introduction Unfortunately, no existing methods are known to the authors that

satisfy all the desired properties. In particular, the robustness of the
Polygonal representations are widely used in computer systems repair method is hard to guarantee, especially for huge input models
and applications for modeling 3-dimensional geometry. Polygo- with numerous mesh defects. In this paper, we present a satisfactory
nal models can be created from various sources, such as 3D range solution using a volumetric approach. Our method takes a polygon
scans and computer-aided design software. However, due to limita- soup (e.g., the horse in figure 1 left) as input, constructs an interme-
tions of these creation methods, the resulting polygonal models of- diate volume grid, and generates the output surface (e.g., the horse
ten cannot be directly utilized by applications that require a closed in figure 1 right) by contouring the grid. The method is guaran-
model as input. By saying closed, we mean that the surface of the teed to produce a closed and consistently oriented surface for any
model partitions the entire space into disjoint internal and external arbitrary input polygonal model. By using memory-less operations
volumes, so that each polygon lies between an internal volume and and divide-and-conquer techniques, input models with millions of
an external volume. A non-closed model often contains mesh de- triangles can be repaired on a consumer level PC in minutes. As an
fects such as gaps, holes, self-intersecting polygons, etc. Figure option, our method is also capable of reproducing sharp features on
the input surface, which is particularly suitable for repairing CAD
∗ e-mail: [email protected] models.

1.1 Contributions
Although other volumetric techniques have been proposed for re-
pairing polygon models [Nooruddin and Turk 2003] or filling holes
on the model surface [Curless and Levoy 1996; Davis et al. 2002],
our method differs substantially in the following aspects:
 2.2 Volumetric model repair
A volumetric approach to model repair involves representing the in-
put model on a volumetric grid and reconstructing an output surface
from the grid. Several approaches have been proposed for perform-
ing each task, which we shall review separately. (Note that a related
problem considers surface reconstruction from scattered points via
an intermediate volume, such as [Ohtake et al. 2003].)

2.2.1 Volume construction

Converting a polygonal model into a volume representation is of-

Figure 2: Three non-closed curves (top) and three closed curves ten referred to as scan-conversion or voxelization. To be able to
(bottom). Vertices are represented by dots, internal volumes are reconstruct a closed surface, the key is to to determine, at each grid
colored dark gray and external volumes are colored light gray. point, a sign indicating whether it lies inside or outside the model.
Hence we can classify scan-conversion techniques by the way they
generate signs on the volume.
1. Unlike previous methods that rely on a uniform volume grid, The first class of scan-conversion methods only detect cells on
we employ a space-efficient octree grid that allows the input the volume that intersect with the model surface without generat-
model to be repaired and reconstructed at a higher resolution ing signs, such as [Huang et al. 1998] and [Dachille and Kaufman
with less space consumption. Correspondingly, we present a 2000]. However, the volumetric representations generated by these
fast, memory-less and numerically robust algorithm for scan- methods are thin-shelled, thus do not possess inside and outside
converting an arbitrary input model onto an octree grid. partitions.
2. The core of our method is a simple and robust algorithm The second class of methods generate a signed volume directly
for determining, at each point on the grid, a sign indicating from the input model. Frisken et al. [Frisken et al. 2000] generate
whether the point lies inside or outside the input model. The a signed distance at each grid point by computing the minimum
signs are generated as a post-process on the scan-converted signed distance from the grid point to each input polygon. However,
grid and requires no global iterations. Our algorithm can be the method fails when input model contains inconsistently oriented
efficiently implemented as recursive procedures on the octree. polygons (e.g., non-orientable surfaces).
In a different approach, Nooruddin and Turk [Nooruddin and
3. Unlike previous volumetric approaches that generate blobby Turk 2003] proposed two methods for determining the sign at a
surfaces, by recording Hermite data, we are able to reproduce given grid point directly from input polygons: parity count and ray
sharp features in the original model using Dual Contouring stabbing. Both methods involve casting rays from each grid point
[Ju et al. 2002]. and voting based on the parity or locations of intersections on each
ray with the model. However, since ray casting is a global oper-
ation, a small error on the surface may cause a large portion on
2 Related works the grid at a distant location to be misclassified. Moreover, sign
generation relies on a uniform grid, which makes it difficult for
2.1 Mesh-based model repair representing the model at a high grid resolution.
One class of model repair methods, which we refer to as mesh- The last class of scan-conversion methods generate in-
based methods, operate directly on the polygons in the model to side/outside partitions on the volume as a post process. Andujar
repair various geometric and topological errors. Turk and Levoy et al. [Andujar et al. 2002] first construct an octree grid and then
[Turk and Levoy 1994] introduce mesh zippering for removing determine the inside/outside property of each cell using a robust
overlapping regions on the mesh when merging multiple range scan seed algorithm. Similarly, Oomes et al. [Oomes et al. 1997] first
images. Barequet and Kumar [Barequet and Kumar 1997] describe voxelize triangles onto a uniform grid and then fill the cells inside
an interactive system that closes small cracks by stitching corre- the model using a boundary filling algorithm [Foley et al. 1990].
sponding edges and fills big holes by triangulating the detected These filling algorithms, however, fail if the model contains holes
hole boundary. A different approach is proposed by Borodin et on the surface.
al. [Borodin et al. 2002] who describe gap closing as progres- To be able to determine signs in the presence of holes, two meth-
sive boundary decimation. Recently, Liepa [Liepa 2003] applies ods were introduced for processing complex surfaces: the Space
mesh fairing after hole triangulation so that the patch interpolates Carving method [Curless and Levoy 1996], and the Volumetric Dif-
the shape and density of the surrounding mesh. fusion method [Davis et al. 2002]. Space carving works on surfaces
Mesh-based methods are good at reproducing the original geom- reconstructed from range scans and relies on line of sight infor-
etry, since only regions with mesh defects are detected and repaired. mation from the scanners to determine empty regions on the vol-
However, the output model is not guaranteed to be closed and may ume. Volumetric diffusion, on the other hand, utilizes pre-existing
contain self-intersecting polygons. Moreover, detection of defec- signed distances at each grid point and employs global iterations
tive regions (such as holes) often requires global traversal of the that converge to form a smooth and naturally looking surface. Both
entire model, which is both time-consuming and space-consuming. methods depend on extra information (i.e., line of sight or signed
A related method is proposed by Murali and Funkhouser [Murali distances) that can not be easily or reliably obtained from an arbi-
and Funkhouser 1997], in which the input model is represented as trary polygonal model other than range scans. Moreover, diffusion
a BSP tree and cells on the tree are classified as solid or non-solid. is a global process, which traverses a much larger space than nec-
The output surface always encloses a solid space. Their method, essary to close a hole and can be slow to converge. As a final note,
however, involves expensive operations such as construction of a these two methods are specialized for filling holes, hence the recon-
BSP tree from the input model and solving systems of linear equa- structed surface is not guaranteed to partition the space into disjoint
tions whose size equals the number of input polygons. internal and external volumes.
2.2.2 Surface reconstruction
Surface reconstruction from a signed volume is usually performed
through contouring, which produces a polygonal approximation of
the zero-value isosurface. Contouring algorithms can be classified
into two types: primal methods (such as Marching Cubes [Lorensen
and Cline 1987]) and hybrid methods (such as the Feature Sensitive
Surface Extraction method [Kobbelt et al. 2001] and Dual Contour-
ing method [Ju et al. 2002]). Primal contouring methods extract
polygons by connecting points lying on the grid lines, and generate
blobby surfaces with rounded corners. Hybrid methods allow poly-
gon vertices to be placed inside grid cells to reproduce sharp edges a b
and corners. The volumetric model repair methods that we have re-
viewed [Nooruddin and Turk 2003; Curless and Levoy 1996; Davis
et al. 2002] use primal contouring methods for surface reconstruc-
tion, since the information stored on the volume is not adequate for
reproducing sharp features from the original geometry.

3 Robust model repair pipeline

As illustrated in figure 3, our model repair process consists of three
steps: c d
1. Scan-conversion: Embed the input model in a uniformly
spaced grid, and mark edges on the grid that intersect the poly- Figure 3: Model repair pipeline: the original model (a), an octree
gons as intersection edges. For efficiency, cells containing grid with intersection edges highlighted (b), signs at grid points
intersection edges are stored in an octree (figure 3 (b)). generated from the intersection edges (c), and the final model re-
constructed by contouring (d).
2. Sign generation: At the grid points, generate signs that are
consistent with the intersection edges, so that each cell edge
intersecting the model should exhibit a sign change (figure 3
(c)).

3. Surface reconstruction: Reconstruct a closed surface on the

signed grid by contouring. Dual contouring can be used to
reproduce sharp features when Hermite data is stored on the a b c d
intersection edges (figure 3 (d)).
Figure 4: Recursive steps in scan-converting a polygon onto an oc-
Sign generation is the central step, which results in a partitioning tree.
of space that is essential to the construction of a closed surface.
Our approach relies on the grid edges intersected with the input
polygons, which can be robustly obtained for any type of model Incremental update of the octree is a memory-less operation, in
(even non-orientable surfaces). By adding or removing intersection that no space is necessary for storing the input model. Polygons
edges at appropriate locations, we can always generate consistent are processed one at a time, and are discarded after they are scan-
signs at the grid points. converted. It is therefore particularly suitable for processing large
polygon models, such as 3D range scan data. For example, the
David model at 1mm resolution with over 56 million triangles can
4 Scan-conversion be scan-converted onto an octree grid at the same resolution (at
depth 13) using less than 500 megabytes memory (consider that
In the first step of model repair, we convert the input model to a storing the model itself would take over 1 gigabyte).
volumetric form by constructing an octree grid that records edges
intersecting the input model (i.e., intersection edges). The octree
can be built incrementally as the polygons are read from the input 4.1 Efficient and robust intersection tests
model. Specifically, for each polygon to be processed, we recur-
sively walk down the octree, expanding nodes when necessary, un- Assuming the input polygons are triangles, the main operations in-
til all the leaf cells at the bottom level of the tree that intersect the volved in the scan-conversion process are triangle-cube intersec-
polygon are located (figure 4 (a) to (c)). Then, cell edges that inter- tions and triangle-edge intersections. Both operations can be per-
sect the polygon are identified in those leaf cells and are marked as formed efficiently using the Separating Axes method. Specifically,
intersection edges (figure 4 (d)). a triangle and a cube are disjoint if their projections on any one of
Although intersection edges suffice for the purpose of sign gener- the following 13 vectors are disjoint: the triangle face normal, 3
ation, extra information (e.g., exact intersection points and triangle cube face normals, and 9 pair-wise cross-products of the 3 edges of
normals) can be recorded on each intersection edge for better sur- the cube and the 3 edges of the triangle. Treating a cell edge as a
face reconstruction (see Section 6). To avoid duplication, each leaf degenerate cube, triangle-edge intersection can be tested using the
cell only maintains the extra information on its three primal edges same set of projection vectors as those computed from the triangle
(i.e., edges adjacent to the lower-left-far cell corner), and stores and the cube containing the edge. Since the octree cells and their
the intersection properties of all its edges in a 12-bit mask for fast cell edges are aligned to the primal axes, the projection vectors can
querying. be easily computed once for each triangle and used for perform-
ing all intersection tests on the octree. Table 1 reports the resulting
scan-conversion time for models of various sizes.
Intersection tests using Separating Axes involve floating point
operations that are prone to numerical errors. These errors cause
incorrect identification of cell edges that intersect the polygons,
which may lead to erroneous signs generated in the next step. To
eliminate floating-point errors, we use integer operations to obtain
exact results. Specifically, we embed the octree grid and the input
model inside a fine integer lattice of size 2N in each dimension,
and clamp each grip point and polygon vertex to the nearest lat-
tice point. We choose N = 20 to achieve a comparable accuracy as
single-precision floating-point coordinates. Since vertices of the tri-
angle and the grid cells can be represented by N-bit integers, their
differences are vectors representable by N-bit integers too. Con-
sequently, the 13 projection vectors used in the intersection tests,
which are cross-products of these difference vectors, require 2N-bit
integers. Finally, the projections of triangle and cube vertices on
any of the 13 projection vectors can be represented by integers with
2N + N = 3N bits. As a result, a 64-bit representation suffices for
our integer computation.

5 Sign generation
Given a scan-converted grid, our next task is to determine signs
at the grid points such that each intersection edge exhibits a sign Figure 6: Sign generation via the dual surface: the input model
change (i.e., a consistent sign configuration). However, consistent with an open top (a), edges intersected with the model and the cor-
signs do not exist when a cell face contains an odd number of edges responding dual surface (b) (boundary edges are highlighted), the
that intersect the model, as shown in figure 5. Such cases may arise patched dual surface with corresponding intersection edges (c), and
either due to an insufficient grid resolution (figure 5 left) or a non- the repaired model based on the consistent signs generated (d).
closed input model (figure 5 middle and right). Denote the set of
original intersection edges on the scan-converted grid as E, our goal
is to obtain a modified set Ê of intersection edges that possess a 1. Detect boundary cycles. ∂ (S) is a collection of closed cycles
consistent sign configuration. bi . In fact, since a vertex on S is shared by two edges on each
quad that contains the vertex, every vertex on S is shared by an
even number of boundary edges. Hence ∂ (S) is an Eulerian
graph and can be partitioned into disjoint cycles bi [Bollobas
1979]. The dual surface in figure 6 (b) contains one boundary
cycle at the top.

2. Patch boundary cycles. For each boundary cycle bi , we con-

struct a patch Pi so that ∂ (Pi ) = bi . Let be the symmetric
difference operator1 , we note that ∂ (S Pi ) = ∂ (S) ∂ (Pi ) =
Figure 5: Cell faces (colored gray) containing an odd number of ∂ (S) − bi . Hence taking the symmetric differences between
intersection edges (drawn in black). Input models are shown as every Pi and S results in a patched surface Ŝ, such that ∂ (Ŝ) =
broken lines. 0.
/ Figure 6 (c) shows the patched result of the dual surface in
figure 6 (b).

3. Generate signs. The patched dual surface Ŝ corresponds to

5.1 Overview a new set of intersection edges Ê on the primal grid, where
consistent signs can are generated. Figure 6 (d) shows the
The set E defines a dual surface S, which consists of quads that are repaired model based on the intersection edges shown in 6
dual to the edges in E. Specifically, each quad in S is perpendicular (c).
to an edge in E and centered at the midpoint of that edge. Figure
6 (a) shows an input model, and figure (b) shows the edges on a Next, we will demonstrate how each step can be efficiently im-
depth 4 octree grid intersecting the model and the corresponding plemented on the octree grid as recursive procedures.
dual surface. We introduce a boundary operator ∂ , so that ∂ (S)
extracts the boundary edges (i.e., edges shared by an odd number
of quads) on S (highlighted in figure 6 (b)). Note that each edge in 5.2 Detect boundary cycles
∂ (S) is dual to a cell face on the primal grid that contains an odd Detecting the boundary edges in ∂ (S) simply involves enumerating
number of intersection edges. In other words, ∂ (S) is empty when the cell faces on the primal grid containing an odd number of inter-
all cell faces on the primal grid are well-formed: they contain an section edges. To form cycles, we introduce a bottom-up procedure
even number (0, 2 or 4) of intersection edges. detectProc[N] that returns all complete cycles B and incomplete
The key observation is that, a consistent sign configuration exists cycles (i.e., paths of boundary edges) R inside the octree node N.
for E on the primal grid if and only if ∂ (S) is empty (a brief proof is
given in Appendix A). Therefore, we can proceed in the following 1 The symmetric difference between two sets X and Y is defined as X

three steps for sign generation: Y = X ∪Y − X ∩Y .

The key to the recursion is, a cycle or an incomplete cycle either hull of the boundary cycle b, the resulting quads on the patch P
lies inside a child node, or consists of incomplete cycles in multiple always stay inside the discrete convex hull of b.
children nodes connected by edges crossing the faces between the We shall prove that the recursive procedure always terminates
nodes. At a leaf node, detectProc[N] returns B = 0/ and R = 0. / At and constructs a P with the desired boundary b. In fact, by building
an internal node, detectProc[N] proceeds as follows: Q on a Manhattan path between e1 and e2 , the length of the two
sub-cycles b1 and b2 are strictly less than the length of b. Hence
1. Call detectProc[Ni ] for every child node Ni , which return recursions in b1 and b2 are guaranteed to terminate. To show that
cycles Bi and incomplete cycles Ri . ∂ (P) = b, we observe that when b = 0, / ∂ (P) = 0/ = b. When b 6= 0,/
2. Detect the boundary edges E crossing the faces between adja- assuming that ∂ (P1 ) = b1 and ∂ (P2 ) = b2 , we have ∂ (P) = ∂ (Q
cent children nodes. P1 P2 ) = ∂ (Q) b1 b2 = b.
The divide-and-conquer method naturally leads to a top-down
3. Connect Ri by E to form complete cycles B̄ and incomplete implementation on the octree grid. Let patchProc[N,b] be the
cycles R. B is the union of B̄ and the Bi s. recursive procedure that patches a boundary cycle b inside an octree
node N. By choosing the splitting planes as the center planes of N,
patchProc[N,b] first splits b into sub-cycles bi, j that lie in the
5.3 Patch boundary cycles children nodes Ni . Then patchProc[Ni ,bi, j ] is called for every
Given a boundary cycle b on the dual surface, we need to construct child node Ni and its enclosing sub-cycles bi, j . Note that each bi, j
a patch P so that ∂ (P) = b. We would also like P to contain as few is bounded by a cell that is half the size of b, hence the recursion
quads as possible, so that a minimum portion of the grid is affected is guaranteed to stop after H levels, where H is the depth of the
by patching. The continuous version of the problem is known as octree. To compute the symmetric difference of the patch and the
the Plateau’s Problem, which seeks the surface of minimum area existing dual surface, we only need to negate the intersection/non-
spanning a given curve in 3-D space. The solution to the Plateau’s intersection property of the cell edges dual to the quads in the patch.
Problem involves methods in differential geometry [Douglas 1931].
For efficiency and robustness, we introduce a divide-and-conquer 5.4 Generate signs
method for constructing a P with a boundary cycle b, so that P lies
in the discrete convex hull(i.e., the set of all grid cells contained The patching process results in a new set of intersection edges Ê
or partially contained in the convex hull) of b. (A similar proce- on the primal grid dual to the patched dual surface Ŝ. Since ∂ (Ŝ)
dure was used in [Schroeder et al. 1992] for triangulating a loop of is empty, Ê possesses a consistent sign configuration. We intro-
polygon edges.) duce a recursive procedure signProc[N,s], which generates signs
The method relies on the fact that, as shown on the left of figure in an octree node N given a sign s at the lower-left-far corner, and
7, there exists a splitting plane on the primal grid that intersects a returns the resulting signs at its eight corners as a list. At a leaf
cycle b on the dual surface with two edges e1 and e2 orthogonal to node, signProc[N,s] infers signs at the other seven corners based
the plane. To find P, we first construct a band of quads Q connecting on the intersection edges. At an internal node, signProc[N,s] first
e1 and e2 , which splits b into two sub-cycles b1 and b2 such that calls signProc[N1 ,s], where N1 refers to the lower-left-far child,
b = ∂ (Q) b1 b2 . Assuming that recursions in sub-cycles b1 and and obtains signs at the corners of N1 as si (i = 1, . . . , 8). Then
b2 produce two sub-patches P1 and P2 , respectively, P is formed by signProc[Ni ,si ] is called for every other child node Ni (i 6= 1) with
Q P1 P2 . the sign si at their lower-left-far corners.

6 Surface reconstruction
After signs are determined at each grid point, a closed surface sep-
arating grid points with opposite signs can be constructed using
contouring algorithms. If the locations of the intersection points
are stored on the edges during scan-conversion, a primal contour-
ing algorithm can be used, such as the Marching Cubes algorithm
[Lorensen and Cline 1987]. If normals are attached to the intersec-
tion points in addition to their locations (i.e., a Hermite represen-
tation), we can use Dual Contouring [Ju et al. 2002] to reproduce
sharp features in the original model. In either case, the polygons on
the contoured surface do not self-intersect, and can be consistently
Figure 7: Patch construction by divide-and-conquer. Left: quads Q oriented to face the external volume.
connect edges e1 and e2 orthogonal to the splitting plane and divide
the original cycle into b1 (solid lines) and b2 (broken lines). Right: 6.1 Examples
on the splitting plane, quads Q are dual to cell edges (thickened)
crossing the line h (dashed) connecting the projections of e1 and Figures 8 and 9 demonstrate repairing CAD models with sharp fea-
e2. tures using the presented method. Figure 8 (a) shows a mechanical
part built using a state-of-the-art 3D design software. Note that it is
To construct a patch with low surface area, we let the band of not unusual for CAD software to produce hanging polygons (shown
quads Q follow the plane on which e1 and e2 lie. Specifically, as in this example) during CSG operations. The gears model in figure
shown on the right of figure 7, we connect the projections of e1 9 (a) is also not closed, since the polygons between the top and the
and e2 on the splitting plane with a line segment h (in practice the bottom gear does not lie between an internal volume and an exter-
projections are computed by averaging the locations and normals of nal volume. In both examples, boundary cycles are detected on the
existing edge intersections on the cell faces dual to e1 and e2 ). We corresponding dual surfaces, in which each boundary edge is shared
then construct Q as the quads dual to the cell edges on the primal by one quad (figure 8 (b)) or three quads (figure 9 (b)). The final
grid that cross h (new edge intersections are created when necessary repaired surfaces are reconstructed using the Marching Cubes algo-
by intersecting h with the cell edges and interpolating the normals rithm (figure 8 (c) and figure 9 (c)) and Dual Contouring (figure 8
associated with the end points of h). Since h lies inside the convex (d) and figure 9 (d)). Observe that the dual-contoured surfaces elim-
 reconstructed surface may not look optimal with respect to the sur-
rounding mesh, particularly in places of complex holes with mul-
tiple boundaries or highly curved shapes. Moreover, curved inter-
nal membranes may not be satisfactorily removed as a result of the
simple divide-and-conquer approach. Without compromising the
robustness of our method, we can improve the appearance of the
repaired surface by exploring other means by which the boundary
cycles on the dual surface can be patched. For example, boundary
cycles that are within a distance threshold can be combined, and
existing geometry can be taken into consideration when patching
the cycles. We are also investigating incorporation of diffusion-
based methods [Davis et al. 2002] for creating more natural looking
patches on the dual surface with the surrounding geometry.
Due to the use of an intermediate volume, the reconstructed sur-
Figure 8: A mechanical part model containing hanging triangles (a), face using our method may contain topological redundancy in the
the dual surface with highlighted boundary cycles (b), reconstructed form of handles, cavities, and disconnected components (the genus
surfaces using Marching Cubes (c) and Dual Contouring (d). of each repaired model in this paper are reported in Table 1). Since
a large number of topology repair methods operate directly in the
volume domain, we can adapt these methods to work on the octree
volume produced by the second step (i.e., sign generation) so that
inate the errors in the original models while accurately preserving a topologically acceptable surface is produced by contouring. In
the rest of the geometry, such as sharp edges and corners. particular, we can apply the robust seed algorithm [Andujar et al.
Polygonal models obtained from 3D range images typically have 2002] to remove internal cavities, and the topology simplification
gaps, holes or intersecting polygons. In figure 10, the Bunny model algorithm [Wood et al. 2002] to reduce the genus of the surface.
is repaired using octree grids at different depths and reconstructed Morphological operators introduced in [Nooruddin and Turk 2003]
using Marching Cubes. Observe that the holes at the bottom of the can also be applied to remove small features on the repaired volume
Bunny are repaired at every grid resolution with reasonable appear- if desired.
ance. The geometry of the original model away from the holes are Finally, to reduce triangle count due to the use of contouring al-
faithfully reproduced to the extent that the grid resolution allows. gorithms, we can output the reconstructed mesh to a polygon sim-
To test the robustness of our algorithm, we synthetically distort plifier, such as QSlim [Garland and Heckbert 1997], to obtain a
the Horse model on the left of figure 1 by randomly perturbing the decimated model. Alternatively, if Hermite data are present, QEF
vertex locations in each triangle in the front part, and removing simplification method [Ju et al. 2002] can be applied directly on the
one third of the triangles at random locations in the second part. octree grid, so that the dual-contoured mesh is already simplified to
Despite the numerous self-intersections, gaps and holes on the dis- the desired extent.
torted model, the repaired model on the right consists of a single
closed surface with no self-intersecting triangles. Observe that the 8 Conclusion
repaired surface reproduces both noisy and smooth geometry on the
original model. In this paper we present a robust method for repairing polygonal
models. Given an arbitrary polygonal model represented as poly-
Our model repair method can process huge models efficiently.
gon soups, our method always produces a closed and consistently
Figure 11 (a) shows the statue of Michelangelo’s David recon-
oriented surface. As a volumetric approach, our method employs an
structed at 1mm resolution from 3D range scans. The model con-
octree grid and memory-efficient operations that are capable of pro-
tains over 56 million triangles, and takes up over 1 Gigabyte of
cessing huge models. The output surface is guaranteed to be defect-
memory to store. Figure 11 (b) shows the repaired model using
free due to a simple and robust algorithm for generating signs on the
an octree of depth 13, in which each leaf cell on the octree mea-
octree grid. Sharp features in the input model can also be faithfully
sures approximately 1mm on the model. The repair process finishes
reproduced by storing Hermite data.
within an hour using less than half a gigabyte of memory. Sign gen-
eration on the entire grid, in particular, takes only 45 seconds . Fig-
ure 11 (c) takes close-up looks at the model before and after repair. 9 Acknowledgement
Observe again that the repaired surface accurately reproduces the I would like to thank my advisor, Joe Warren, for his continuous
geometry details, and generates reasonable patches where the data support and insightful comments.
is missing from the original model.
Table 1 reports the time and space consumed for repairing the References
various models in the paper. We also include the results of repair-
ing other models from the Stanford 3D Scanning Repository, such A NDUJAR , C., B RUNET, P., AND AYALA , D. 2002. Topology-
as the Dragon and the Happy Buddha, as well as the David model reducing surface simplification using a discrete solid representa-
reconstructed at 2mm resolution. The experiments are performed tion. ACM Transaction on Graphics 21, 2, 88–105.
on a consumer-level PC with 1.5GHz CPU and 2GB memory, and
I/O operations are included when measuring the scan-conversion BAREQUET, G., AND K UMAR , S. 1997. Repairing CAD models.
and contouring time. Observe that while scan-conversion is sensi- In IEEE Visualization ’97, R. Yagel and H. Hagen, Eds., 363–
tive to the size of the input model, the performance of sign genera- 370.
tion and surface reconstruction only depends on the complexity of B OLLOBAS , B. 1979. Graph Theory: An Introductory Course.
the octree. New York: Springer-Verlag.
7 Discussion and future work B ORODIN , P., N OVOTNI , M., AND K LEIN , R. 2002. Progressive
The goal of our work is to design a simple algorithm for generat- gap closing for mesh repairing. In Advances in Modelling, Ani-
ing a closed surface robustly for any arbitrary input mesh. Due to mation and Rendering, J. Vince and R. Earnshaw, Eds. Springer
the simplicity of our approach, however, the repaired region on the Verlag, July, 201–213.
Figure 9: A gear model (a) that contains a membrane in the middle, the dual surface with a highlighted boundary cycle (b), reconstructed
surfaces using Marching Cubes (c) and Dual Contouring (d). The cross-section views of the original and the repaired model are shown at
their top-right corners.

Figure 10: The original bunny model (a) repaired at octree depth 5 (b), 6 (c) and 7 (d).

Figure 11: Repairing David: the original model at 1mm resolution (a), the repaired model at the same resolution (b), and close-ups on the
model before repair (top row in (c)) and after repair (bottom row in (c)).
 Model Input Octree Octree Scan-conversion Sign generation Contouring Memory Output Surface
Triangles Depth Leaf Cells Time (sec) Time (sec) Time (sec) Usage (MB) Triangles Genus
Mechanic Part 25,487 6 5,449 0.89 0.01 0.094 < 10 5,480 3
Gears 11,610 6 9,316 0.86 0.03 0.14 < 10 8,926 0
Bunny 69,451 7 46,028 2.75 0.06 0.79 < 10 91,716 0
Horse 80,805 8 93,164 3.62 0.31 2.14 < 10 163,692 1
Dragon 871,414 9 543,449 37.16 0.69 7.92 16 1,085,404 2
Buddha 1,087,716 10 1,716,718 56.47 2.02 18.22 28 3,425,781 11
David (2mm) 8,254,150 12 6,539,335 362.98 8.20 133.75 92 13,059,000 15
David (1mm) 56,230,343 13 31,561,029 2482.14 45.82 661.64 417 62,825,040 179

Table 1: Performance results on repairing various models on a consumer level PC with 1.5GHz CPU and 2GB memory.

C URLESS , B., AND L EVOY, M. 1996. A volumetric method for M URALI , T. M., AND F UNKHOUSER , T. A. 1997. Consistent solid
building complex models from range images. In Proceedings of and boundary representations from arbitrary polygonal data. In
ACM SIGGRAPH 1996, ACM Press / ACM SIGGRAPH, New Proceedings of the 1997 symposium on Interactive 3D graphics,
York. E. Fiume, Ed., Computer Graphics Proceedings, Annual ACM Press, 155–ff.
Conference Series, ACM, vol. 30, 303–312.
N OORUDDIN , F. S., AND T URK , G. 2003. Simplification and
DACHILLE , F., AND K AUFMAN , A. 2000. Incremental triangle repair of polygonal models using volumetric techniques. IEEE
voxelization. In Graphics Interface, 205–212. Transactions on Visualization and Computer Graphics 9, 2, 191–
205.
DAVIS , J., M ARSCHNER , S. R., G ARR , M., AND L EVOY, M.
2002. Filling holes in complex surfaces using volumetric diffu- O HTAKE , Y., B ELYAEV, A., A LEXA , M., T URK , G., AND S EI -
sion. In First ’International Symposium on 3D Data Processing, DEL , H.-P. 2003. Multi-level partition of unity implicits. ACM
Visualization, and Transmission. Transactions on Graphics 22, 3, 463–470.
D OUGLAS , J. 1931. Solution of the problem of plateau. Transac- O OMES , S., S NOEREN , P., AND D IJKSTRA , T. 1997. 3d
tions of the American Mathematical Society 33, 263–321. shape representation: Transforming polygons into voxels. In
ScaleSpace97.
F OLEY, J. D., VAN DAM , A., F EINER , S. K., AND H UGHES , J. F.
1990. Computer Graphics (2nd Edition). Addison-Wesley Pubi- S CHROEDER , W. J., Z ARGE , J. A., AND L ORENSEN , W. E. 1992.
cation Company. Decimation of triangle meshes. In Computer Graphics (Proceed-
ings of ACM SIGGRAPH 92), ACM Press, 65–70.
F RISKEN , S. F., P ERRY, R. N., ROCKWOOD , A. P., AND J ONES ,
T. R. 2000. Adaptively sampled distance fields: A general rep- T URK , G., AND L EVOY, M. 1994. Zippered polygon meshes from
resentation of shape for computer graphics. In SProceedings of range images. In Proceedings of ACM SIGGRAPH 1994, ACM
ACM SIGGRAPH 2000, ACM Press / ACM SIGGRAPH, New Press / ACM SIGGRAPH, New York. E. Fiume, Ed., Computer
York. E. Fiume, Ed., Computer Graphics Proceedings, Annual Graphics Proceedings, Annual Conference Series, ACM, 311–
Conference Series, ACM, K. Akeley, Ed., 249–254. 318.
G ARLAND , M., AND H ECKBERT, P. S. 1997. Surface simplifica- W OOD , Z., H OPPE , H., D ESBRUN , M., AND S CHRODER , P.
tion using quadric error metrics. In Proceedings of ACM SIG- 2002. Isosurface topology simplification. Technical Report
GRAPH 1997, ACM Press / ACM SIGGRAPH, New York. E. MSR-TR-2002-28, Microsoft Research (January).
Fiume, Ed., Computer Graphics Proceedings, Annual Confer-
ence Series, ACM, 209–216.
A Existence of consistent signs
H UANG , J., YAGEL , R., F ILIPPOV, V., AND K URZION , Y. 1998.
An accurate method for voxelizing polygon meshes. In IEEE Proposition: An octree grid with intersection edges E can be
Symposium on Volume Visualization, 119–126. consistently signed if and only if its dual surface S contains no
boundary edges, that is, ∂ (S) = 0.
/
J U , T., L OSASSO , F., S CHAEFER , S., AND WARREN , J. 2002.
Dual contouring of hermite data. ACM Transactions on Graphics Proof: Observe that a consistent sign configuration exists if and
21, 3, 339–346. only if every closed circuit of edges on the grid contains an even
number of intersection edges. In particular, since a cell face is a
KOBBELT, L. P., B OTSCH , M., S CHWANECKE , U., AND S EIDEL , closed circuit of four edges, every cell face should contain an even
H.-P. 2001. Feature sensitive surface extraction from volume number of intersection edges if a consistent sign configuration ex-
data. In Proceedings of ACM SIGGRAPH 2001, ACM Press / ists, hence the dual surface contains no boundary edges. To prove
ACM SIGGRAPH, New York. E. Fiume, Ed., Computer Graph- sufficiency, we assume that a consistent sign configuration does not
ics Proceedings, Annual Conference Series, ACM, 57–66. exist. Among all closed circuits on the grid containing an odd num-
ber of intersection edges (referred to as odd circuits), we find the
L IEPA , P. 2003. Filling holes in meshes. In Proceedings of the
one with the shortest length and denote it as b. Following a similar
Eurographics/ACM SIGGRAPH symposium on Geometry pro-
argument as in Section 5.3, b can be split into two sub-circuits, b 1
cessing, Eurographics Association, 200–205.
and b2 , by a band of cell faces Q in the middle (see figure 7 left).
L ORENSEN , W., AND C LINE , H. 1987. Marching cubes: A Since b1 and b2 are strictly shorter than b, they can not be odd cir-
high resolution 3d surface construction algorithm. In Computer cuits. Hence at least one cell face in Q contains an odd number of
Graphics (Proceedings of ACM SIGGRAPH 87), ACM Press, intersection edges. In other words, a boundary edge must exist on
vol. 21, 163–169. the dual surface. This completes the proof.