Fast and Effective Feature-Preserving Mesh Denoising.

Abstract

We present a simple and fast mesh denoising method, which can
remove noise effectively while preserving mesh features such as sharp
edges and corners. The method consists of two stages. First, noisy
face normals are filtered iteratively by weighted averaging of
neighboring face normals. Second, vertex positions are iteratively
updated to agree with the denoised face normals. The weight function
used during normal filtering is much simpler than that used in
previous similar approaches, being simply a trimmed quadratic. This
makes the algorithm both fast and simple to implement. Vertex position
updating is based on the integration of surface normals using a
least-squares error criterion. Like previous algorithms, we solve the
least-squares problem by gradient descent; whereas previous methods
needed user input to determine the iteration step size, we determine
it automatically. In addition, we prove the convergence of the vertex
position updating approach. Analysis and experiments show the
advantages of our proposed method over various earlier surface
denoising methods.

Full text

Page 1

1
Fast and Effective Feature-Preserving
Mesh Denoising
Xianfang Sun, Paul L. Rosin, Ralph R. Martin, and Frank C. Langbein, Member, IEEE
Abstract—We present a simple and fast mesh denoising
method, which can remove noise effectively, while preserving
mesh features such as sharp edges and corners. The method
consists of two stages. Firstly, noisy face normals are filtered
iteratively by weighted averaging of neighboring face normals.
Secondly, vertex positions are iteratively updated to agree with
the denoised face normals. The weight function used during
normal filtering is much simpler than that used in previous
similar approaches, being simply a trimmed quadratic. This
makes the algorithm both fast and simple to implement. Vertex
position updating is based on the integration of surface normals
using a least-squares error criterion. Like previous algorithms, we
solve the least-squares problem by gradient descent, but whereas
previous methods needed user input to determine the iteration
step size, we determine it automatically. In addition, we prove the
convergence of the vertex position updating approach. Analysis
and experiments show the advantages of our proposed method
over various earlier surface denoising methods.
Index Terms—Mesh smoothing, mesh denoising, feature
preservation.
I. INTRODUCTION
3
modelling, virtual reality, and computer games. Some 3D
surface models are generated via geometric, physical, and
solid modelling, whereas others are acquired through 3D
measurement technologies such as 3D cameras which produce
depth maps, and ship-based sonar. Measured mesh models
often contain noise, introduced by the scanning devices and
the digitization processes. Such noise can severely impact the
usability of mesh models, and it is often desirable to filter it
out in a preprocessing step.
In the literature, 3D mesh denoising is often confused
with surface smoothing or fairing. Here we wish to empha-
sise the distinction: in smoothing or fairing, the aim is to
generally remove certain high-frequency information in the
mesh, whereas in denoising, the aim is to preserve genuine
information at all frequencies, while removing any noise or
spurious information. In particular, in this paper, we aim to
preserve sharp features in the mesh, while removing noise. As
Tasdizen et al. [1] point out, much surface smoothing research
has been done in the context of surface fairing, with the aim
of creating aesthetically pleasing mesh surfaces. However, we
follow Shen et al. [2] and clearly distinguish surface fairing
D surface mesh models are used in many fields such
as CAD, reverse engineering, architectural design, terrain
Manuscript received
The authors are with the School of Computer Science, Cardiff University, 5
The Parade, Roath, Cardiff CF24 3AA, UK. X. Sun is also with the School of
Automation Science and Electrical Engineering, Beihang Univerisity, Beijing
100083, P.R. China.
from denoising: the later focuses on removing local errors
caused by e.g. 3D sensing technologies, or perhaps by finite
element simulation. Mesh filtering is another phrase often used
to describe similar processes applied to meshes. Filters take
one mesh as input and process it to produce another as output.
Noise removal is clearly one thing that can be done by such
a filter.
In general terms, mesh denoising can be seen as a require-
ment to adjust vertex positions—vertices affected by noise
are not where they should be, and should be moved to the
best estimates of their true positions without added noise.
(Generally, the vertex positions are the primary measured data,
not mesh triangles, which is why we adjust vertex positions).
In practice, adjusting vertices directly is not always done,
however. New vertex coordinates can be computed in one step
or two. One-step approaches directly update vertex positions
using the original vertex coordinates, and sometimes face
normals too, in a neighbourhood around the current vertex.
Two-step approaches firstly adjust face normals and then
update vertex positions using some error minimization criteria
based on the adjusted normals. In many cases, a single pass of
a one-step or two-step approach does not yield a satisfactory
result, and iterated operations are performed.
In iterative two-step approaches, the iterations can be per-
formed in two distinct ways: the two steps can be coupled as a
pair to give an overall iteration procedure informally described
as (Step 1 + Step 2)n, or two separate iteration phases can
be performed: informally (Step 1)n1+ (Step 2)n2; here n,
n1 and n2 are numbers of iterations. To distinguish these
two schemes, we call these one-stage and two-stage iteration
schemes respectively.
The relative advantages of these two schemes merits de-
tailed investigation. One seeming advantage of one-stage iter-
ation over two-stage iteration is that the former only involves
one iteration parameter n, while the latter has two iteration
parameters, n1 and n2. However, the two-stage scheme is
generally likely to require fewer iterations to obtain a given
degree of denoising, i.e., max(n1,n2) < n, for two reasons.
Firstly, note that normal updating in a two-stage scheme is
based on the previously updated normals, while the normal
updating in a one-stage scheme is based on the normals
computed from the previously updated vertices. Generally,
these normals will not be the same; if the normal updating
algorithm is optimal in each iteration, then the normals used
in a two-stage scheme will be better than those used in
a one-stage scheme. Hence, to obtain the same degree of
denoising, n is likely to be greater than n1. Secondly, a similar
consideration applies to vertex updates. Vertex updating is

Page 2

2
based on previously obtained normals. Vertex updating in a
two-stage scheme is based on the final (optimal) normals,
while vertex updating in a one-stage scheme is based on
the most recently updated normals. If the vertex updating
algorithm is optimal in each iteration, then n is likely to be
greater than n2to obtain the same degree of denoising.
The approach proposed in this paper is an iterative, two-step
method. Our first step adjusts the face normals and our second
step updates the vertex positions. Because for an iterative two-
step method, the two-stage iteration scheme has the advantage
of fewer iterations, we adopt a two-stage scheme for our two-
step method.
II. PREVIOUS WORK
Many surface smoothing and denoising methods have been
proposed, and to a large degree their differing aims have
been conflated—smoothing algorithms have often been sug-
gested for noise removal. The classical Laplacian smoothing
method [3], [4] is the fastest and simplest surface smooth-
ing method. However, when applied to a noisy 3D surface,
significant shape distortion and surface shrinkage may result
in addition to noise removal. To overcome the shrinkage
problem, Taubin [5] proposed a filtering method with positive
and negative damping factors. A first-order filter with positive
damping shrinks and smooths the mesh surface, while a first-
order filter with negative damping expands the surface, to
compensate for shrinkage. This method is fast and simple, but
still has the problem of distortion of prominent mesh features.
In addition, if the parameters of the two filters are not chosen
carefully, the algorithm can be numerically unstable.
Desbrun et al. [6] introduced diffusion and curvature flow
into surface fairing and proposed a simple and numerically
stable implicit filtering method, which can deal with irregular
meshes. They overcome the problem of shrinkage by re-
scaling the mesh to preserve its volume. Again, however,
distortion of prominent mesh features occurs.
Taubin’s [5] and Desbrun et al.’s [6] methods can both be
considered as filtering methods from the viewpoint of signal
processing. The former can be considered as a moving average,
or finite impulse response filtering, while the later can be
seen as autoregressive, or infinite impulse response filtering.
Combining the above two approaches, Kim and Rossignac [7]
developed a general autoregressive moving average filter ap-
proach. Through suitable choice of parameters, the filter can
act as a lowpass, bandpass, highpass, notch, band amplification
or band attenuation filter, thus enabling it to filter out e.g. high-
frequency noise and, at the same time, enhance or suppress
certain features. However, it is difficult to design a suitable
filter that can preserve sharp, high frequency features at the
same time as removing noise.
The above methods are all isotropic filtering methods, in
which the filter acts independently of direction. This makes
it hard for such filters to preserve prominent directional
mesh features, particularly edges. Thus, various anisotropic
filtering schemes have been proposed which smooth surfaces
yet preserve edge features simultaneously.
Anisotropic filtering schemes can be divided into four
classes. The first class is based on anisotropic geometric diffu-
sion [1], [8]–[11]. Such methods have been used for smoothing
height fields and bivariate data [9], level set surfaces [1], and
general discretized surfaces [8], [10], [11].
The second class is based on bilateral filters [12], [13].
Fleishman et al. [13] use an iterative one-step approach, in
which new vertex coordinates are computed directly from
the vertex’s neighbourhood. This approach is relatively fast
because a one-step computation is needed for each iteration
of vertex updating. However, our experiments show that this
method does not always accurately preserve fine features of
a mesh. Jones et al.’s [12] robust estimation smoothing is a
non-iterative two-step approach. Although non-iterative, this
approach is slow because it treats normal smoothing and vertex
updating as global problems.
The third class is based on combining normal filtering and
vertex position updating [14]–[18]. Yagou et al.’s [15], [16]
mean, median, and alpha-trimming methods, and Chen and
Cheng’s [18] sharpness dependent method are one-stage iter-
ative two-step approaches. Taubin’s [14] anisotropic filtering
algorithm and Shen and Barner’s [17] fuzzy vector median
filtering approach are two-stage iterative two-step approaches.
The final class of approach comprises an assortment of other
methods [2], [19], [20]. Shen et al.’s [2] method consists of
three steps: feature-preserving pre-smoothing, feature and non-
feature region partitioning, and feature and non-feature region
smoothing using two separate approaches. Nehab et al. [19]
presented an energy minimization method with the energy
being the sum of the position error and the normal error. Diebel
et al. [20] used a Bayesian technique for reconstruction and
decimation of noisy 3D surface models, converting surface
smoothing into an energy minimization problem where the
energy is again a sum of the position error and the normal
error. The differences between the latter two methods are that
the former uses additional information about the measured
normals that the latter does not, and the former yields a linear
solution unlike the latter.
All the above surface smoothing or denoising methods are
based on surface mesh models. In recent years, the point-
based surface model has received increasing attention as an
alternative surface representation [21]–[23]. Surface smooth-
ing or denoising methods corresponding to the point-based
models were also investigated [24], [25]. Although this is a
promising research field, this paper only focuses on surface
mesh denoising.
The above anisotropic filtering approaches either do not pre-
serve features effectively, or are complex and computationally
expensive. From an analysis of earlier anisotropic filtering
approaches, we introduce a novel, simple and fast approach
which can effectively preserve features. Our approach uses
the same two steps as [14] and [17], but it is significantly
simpler, and yields results comparable to those of [17].
III. NOTATION
A triangular mesh is denoted by T = (V,E,F,X), where
V = {i : i = 1,...,n} is the vertex set, E = {(i,j) : (i,j) ∈
V × V } is the edge set, F = {(i,j,k) : (i,j),(i,k),(j,k) ∈
E} is the triangular face set, and X = {xi: xi∈ R3, i ∈

Page 3

3
i
Fig. 1. Face neighbourhoods. Faces labeled I belong to NFI(i); faces labeled
II belong to NFII(i)
.
V } is the vertex coordinate set. We use | · | to denote the
cardinality of a set. A vertex, edge, or face is sometimes
loosely represented by its corresponding index, i.e. a number
i may be used to denote the ithvertex Vi, edge Ei, or face Fi,
where this is not ambiguous. The area of face Fiis denoted
by Ai; the normal of Fiis denoted by ni. ∂Fidenotes the set
of edges that constitute the boundary of face Fi.
In algorithms, various quantities are iteratively updated. We
use?to represent the updated value, relative to the current
value: e.g n?
The 1-ring vertex neighbourhood of a vertex Vi, denoted
by NV(i), is the set of vertices that are connected to Vi by
an edge. The set of faces that share a common vertex Vi is
denoted by FV(i). The faces in the 1-ring face neighbourhood
of a face Fi can be divided into two types. The first type,
denoted by NFI(i), is the set of faces that have a common
vertex or edge with the face Fi. The second type, denoted
by NFII(i), is the set of faces that share an edge with the
face Fi. Fig. 1 shows the two types of face neighbourhoods.
Clearly, NFI(i) ⊃ NFII(i). To refer to the union of Fiand
its neighbourhood, we define N∗
N∗
idenotes the updated value of ni.
FI(i) = NFI(i)?{Fi} and
FII(i) = NFII(i)?{Fi}.
IV. NORMAL FILTERING
This Section now considers how we filter normals in our
two-step approach; the next Section considers how we perform
vertex updating. In each case, we start by analysing existing
approaches, using the results to justify our approach.
A. Previous approaches to normal filtering
Several filtering techniques have been proposed to adjust
face normals. An indirect approach to normal filtering is given
by Jones et al. [12], where the face normals are updated
indirectly via vertex updating. A virtual vertex update is first
performed using weighted Gaussian filtering. The real vertex
positions remain unchanged, but the virtual vertex coordinates
are used to compute the new face normals. Although this ap-
proach to normal filtering removes noise, it does not consider
the requirement to preserve fine features.
Most other normal filtering approaches update the normals
directly from the original face normals. Yagou et al. [15],
[16] use mean, median, and alpha-trimming filters. Shen and
Barner [17] use a fuzzy vector median filter to compute the
new normals. We now consider the properties of these filters.
ii
(a)(b)
Fig. 2.
Blue lines are ridge lines; the dotted green line is also a ridge line for a
different case. The areas between the ridge lines are approximately flat.
Faces Fiis adjacent to (a) a ridge feature and (b) a corner feature.
The mean filtering approach [15] computes the updated
normal of a face using area-weighted averaging of the normals
of its neighbours:

j∈NFI(i)Aj
where normalise(·) scales a vector length to 1. Note that
the scaling coefficient 1/?
because of the subsequent normalisation. Surprisingly, several
other papers also needlessly use a scaling coefficient followed
by normalisation: e.g. see [17], [26].
Although mean filtering smooths face normals, it also has
the same limitation as Jones et al.’s [12] approach: it destroys
fine features of the mesh, and is not feature-preserving.
The median filtering approach [15] determines the updated
normal n?
between the normals of face Fi and its neighbouring faces
Fj,j ∈ NFI(i):
n?
n?
i= normalise

1
?
?
j∈NFI(i)
Ajnj

,
(1)
j∈NFI(i)Ajin the above formula
is actually unnecessary, and only adds computational cost
iof a face Fi according to the angles ∠(ni,nj)
i= argmediannj{wj? ∠(ni,nj) : j ∈ NFI(i)},
where wj? ∠(ni,nj) means that wj copies of ∠(ni,nj)
should be included when performing the median operation.
Different choices may be used for wj. A simple choice is to
set all wj = 1, i.e. to use an unweighted median. Another
choice proposed in [15] is to set wj = 2 when Fj ∈ NFII
and wj= 1 when Fj∈ (NFI\ NFII) (weights are shown in
Fig. (2)). Yagou et al. [15] claim that this weighted median
filter better preserves features than the unweighted one.
Such median filters preserve ridge and even corner features
when there is little or no noise on the mesh. However, when
there is a high level of noise, the median filter may yield poor
results, as we now explain.
First, consider the surfaces shown in Figs. 2(a) and 2(b)
separated by the blue ridge lines (ignore the dotted green line).
When there is little or no noise, Eqn. (2) selects as median
normal the normal of a face sharing the same flat area as Fi,
leading to an updated normal for Fiwith little error. However,
if the noise level is high, the median normal may come from
a different flat area to Fi, and the updated normal of Fiwill
then have a large error.
Next, consider a corner also including an additional ridge
line, shown as a dotted green line in Fig. 2(b). It is clear that
(2)

Page 4

4
in this case, the median normal will come from a flat area
different from the one to which Fi belongs, even if there is
no noise on the mesh. Thus, there will be a significant error
in the updated normal for Fi.
When using the median filter, because the updated normal
n?
in nj also exists in the updated normal n?
eliminate noise solely by using a median filter.
The alpha-trimming filtering approach [16] is a compromise
between mean and median filters. It updates the normals in the
following way:

j∈NFI(i)
where Iα(j) is an indicator function, which equals 0 when
∠(ni,nj) is in the top or bottom proportion α of all angle
values ∠(ni,nj), j ∈ NFI(i), and 1 otherwise. When α = 0,
this filter is the same as the mean filter, and when α = 0.5 it is
the same as the median filter. Yagou et al. [16] suggested that
α = 0.2 is a good choice for smoothing models with sharp
features. However, it also unavoidably weakens sharp features
to some extent. For example, suppose little or no noise exists
on the mesh in Fig. 2(a). If we choose α = 0.2, we will ignore
two faces above the blue line and two below. The remaining
faces include faces belonging to a different flat area from Fi,
and so the averaging operation will inappropriately include
normals from the wrong side of the ridge.
The fuzzy vector median filter [17] computes normals using
two steps. Firstly, a vector median of the normals is computed
using:


hood, either N∗
distance function between njand nk, using either the Lpnorm
?nj− nk?p or the angle ∠(nj,nk). Secondly, the updated
normal n?

j∈N∗
where˜Rj,m is a fuzzy relation between nj and nm, which
takes the form of a Gaussian function in [17],
˜Rj,m= exp?−d(nj,nm)2/2σ2?;
σ is a parameter that can be either determined by the user, or
adaptively computed according to a cost function [17]. (Eqn. 5
differs from the version given in [17] as we have eliminated
an unnecessary normalisation, as explained earlier).
As in the case of Yagou et al.’s [15] median filter, again
taking the ridge face example shown in Fig. 2, when there is
little or no noise, the vector median nm given by Eqn. (4)
chooses the normal of a face that shares the same flat area
with Fi; when the noise level is high, nm can come from
a different flat area to Fi. However, because both Fiand its
iis selected from the normals nj(j ∈ NFI(i)), noise present
i. It is hard to
n?
i= normalise

?
Iα(j)Ajnj

,
(3)
nm= argmin
nj

?
k∈N∗
F(i)
d(nj,nk) : j ∈ N∗
F(i)


,
(4)
where N∗
F(i) is the union of face Fiand its face neighbour-
FI(i) or N∗
FII(i) as desired, and d(nj,nk) is a
iis computed as
n?
i= normalise

?
F(i)
nj˜Rj,m

,
(5)
(6)
neighbourhood are used in the computation in Eqn. (4), nm
is more likely to come from a face sharing the same flat area
as Fi than the n?
we use the neighbourhood N∗
comes from a face sharing the same flat area as Fi even in
cases like the one including the additional green dotted ridge
line in Fig. 2(b).
The above analysis shows that Eqn. (4) is expected to
produce better results than Eqn. (2). However, Eqn. (4) is more
time consuming to compute than Eqn. (2). Furthermore, if we
replace NFI(i) in Eqn. (2) by N∗
has similar properties to those produced by Eqn. (4).
Because nmis selected from the normals nj(j ∈ N∗
it is subject to noise. As Eqn. (5) is a weighted average of the
normals in N∗
a Gaussian weight function gives very low weights to those
normals widely different from nm, Eqn. (5) can effectively
average normals that do not come from the same flat area as
nm. Compared to the alpha-trimming filter algorithm Eqn. (3),
which uses the face areas as weights, the fuzzy vector median
filter algorithm can yield normals with lower error, but has
the disadvantage of using Gaussian weights which increase
the computational costs.
icomputed using Eqn. (2). Furthermore, if
FII(i), it is most likely that nm
FI(i) or N∗
FII(i), the result
F(i)),
F(i), the resulting n?
ican denoise ni. Because
B. Our approach to normal filtering
Taking the above analysis into account, we can now give
a new algorithm for normal filtering with low computational
cost, while still yielding a face normal with low error even
for faces adjacent to a ridge or a corner. We perform normal
updates using:

n?
i= normalise

?
j∈N∗
F(i)
hjnj

,
(7)
where hjis a weight function defined as
?
Here, 0 ≤ T ≤ 1 is a threshold determined by the user, used
to control averaging, and f(x) can be any suitably chosen
monotonically increasing function for x ≥ 0. Our experiments
showed that f(x) = x2is a good choice.
The motivation behind the weight function Eqn. (8) is to
give high weights to those face normals close to niand low
weights to those far from ni. In addition, when a face i is
adjacent to a ridge or a corner, we want to give null weight
to the normal njof any face j which does not share the same
surface with face i, and thus having nj far from ni. Note
that ni· nj= cos∠(ni,nj), so f(x) being a monotonically
increasing function implies that the weight function defined
by Eqn. (8) satisfies the above requirements.
The choice of T determines how many normals will be used
in the weighted averaging operation. T = 1 means that only
normals with nj equal to ni are included in the weighted
average, while T = 0 means that all normals with an angle
less than π/2 from niare used. When the mesh surface has
sharp edges, a larger value of T is appropriate, whereas when
hj=
f(ni· nj− T)
0
if ni· nj> T
if ni· nj≤ T
.
(8)

Page 5

5
the surface is relatively smooth, T should be smaller. We will
further discuss the choice of T in Section VI.
Compared to the alpha-trimming filtering algorithm, our
algorithm is an improvement since it gives greater weight to
normals close to ni and eliminates normals that are widely
different from ni: the alpha-trimming algorithm can get rid of
normals close to nias well as those varying widely from it.
Compared to the fuzzy vector median filtering algorithm,
our algorithm is less time-consuming because we do not need
to compute the vector median, and our weight function is
simpler than its Gaussian weights. While that algorithm uses
the vector median operation to find a normal whose corre-
sponding face shares the same surface with Fi, we simplify
this operation and use nias nmin Eqn. (4).
V. VERTEX POSITION UPDATING
A. Previous approaches to vertex updating
After adjusting the face normals, the vertex positions are
updated based on these new normals. Several algorithms exist
to do this. Taubin [14] used orthogonality between the normal
and the three edges of each face on the mesh to give the
following family of simultaneous linear equations for vertex
position updating:


solution, Taubin [14] proposed to solve it in a least squares
sense, i.e. to minimize the following error function:
?
Because this least squares problem is linear and its normal
equations have a symmetric sparse matrix, it can be solved
using various efficient linear system solvers, such as LU, QR,
or Cholesky factorization [27]–[29], gradient descent [14],
[17], the conjugate gradient method [19], [28], or an multigrid
iterative solver [28], [29]. The respective advantages and
disadvantages of these solvers were investigated in [28].
In Taubin’s paper [14] (see also [17]), the gradient descent
method is used to minimize e1(X), so vertex position updating
is implemented as:
?
where λ > 0 is the iteration step size. Careful choice of λ is
crucial: λ too large results in an unstable algorithm, while λ
too small increases the time taken to achieve convergence.
Ohtake et al. [30] proposed the minimization of a different
error function defined by
e2(X) =1
3
i∈F
using the L2norm. Gradient descent is again used to solve this
problem. The solution involves computation of the gradients
of Ai, and Ai(n?

nf· (xj− xi)
nf· (xk− xj)
nf· (xi− xk)
=
=
=
0
0
0
,
∀f = (i,j,k)
(9)
Since in general this system of equations has no non-trivial
e1(X) =
k∈F
?
(i,j)∈∂Fk
(n?
k· (xi− xj))2.
(10)
x?
i= xi+ λ
j∈NV(i)
?
(i,j)∈∂Fk
n?
k(n?
k· (xj− xi)),
(11)
?
Ai?ni− n?
i?2,
(12)
i· ni). This algorithm is computationally
more expensive than Taubin’s, and again has the problem of
choosing a suitable step size λ.
Ohtake et al. [31] also gave another vertex updating algo-
rithm:
1
?
where ck is the centre of the triangle Fk. This equation can
be rewritten as:
x?
i= xi+
k∈FV(i)Ak
?
k∈FV(i)
Akn?
k(n?
k· (ck− xi)),
(13)
x?
i= xi+
(14)
1
3?
k∈FV(i)Ak
?
j∈NV(i)
?
(i,j)∈∂Fk
Akn?
k(n?
k· (xj− xi)),
Although the reasoning behind this algorithm was not pre-
sented in [31], it can be simply explained as the minimization
by gradient descent of the error function:
?
with step size 1/6?
problem of choosing a step size, but it is computationally more
expensive since it needs to compute triangle areas.
Next, we explain the relationship between Ohtake et al.’s
algorithm [31] and Jones et al.’s algorithm [12]. Rearranging
Eqn. (13), we may write:
1
?
where pk(i) = xi+ n?
vertex Vi onto the plane Π?
and Π?
containing the original triangular face Fksince its normal has
been changed from nkto n?
Eqn. (16) implies that the updated vertex coordinate is the
area-weighted average of the projections of the vertex Vionto
the modified planes whose original triangular faces have the
common vertex Vi. The vertex update algorithm proposed by
Jones et al. [12] also computes a weighted average of the
projections of the vertex onto the modified planes, as follows:
i=1
si
k∈F
where both f(·) and g(·) are Gaussian functions, and siis a
normalizing factor:
?
Two differences exist between Ohtake et al.’s algorithm and
Jones et al.’s algorithm. Firstly, the weight computation in
Eqn. (17) is more complicated than that in Eqn. (16). Secondly,
the faces used in the computation of Eqn. (17) include all faces
of the mesh, while Eqn. (16) includes only the faces of FV(i).
Clearly the former is much more costly to compute. However,
the additional complexity of Jones et al.’s algorithm means that
it preserves features better, and does not need to be iterated.
e3(X) =
k∈F
?
(i,j)∈∂Fk
k∈FV(i)Ak.
Ak(n?
k· (xi− xj))2
(15)
Unlike Taubin’s algorithm, this method does not have the
x?
i=
k∈FV(i)Ak
?
k∈FV(i)
Akpk(i),
(16)
k(n?
k· (ck− xi)) is the projection of
kdefined by n?
k· (x − ck) = 0,
kcan be taken as a modification of the plane Πk
k.
x?
?
Akf(?ck− xi?)g(?pk(i) − xi?)pk(i),
(17)
si=
k∈F
Akf(?ck− xi?)g(?pk(i) − xi?).
(18)

Page 6

6
The above methods directly use the face normals to update
vertex position. Recently, Yu et al. [27] proposed an implicit
method to update vertex position through gradient field ma-
nipulation. A new gradient field is computed using the local
rotation matrix derived from niand n?
field is used in a Poisson equation to compute the updated
vertex position. The Poisson equation is linear, and can be
solved by various linear system solvers mentioned above.
This method is promising but needs to be further developed
because of the need for extra computations of the gradient
field. Unfortunately, in our attempts to implement the gradient
field-based vertex updating method, we were unable to obtain
satisfactory results. Perhaps, as Yu et al. [27] suggest, it might
be appropriate to use the solution of this algorithm as the
initialization for further nonlinear optimization by Ohtake et
al.’s algorithm [30].
i, and the new gradient
B. Our approach to vertex updating
In summary, existing vertex updating algorithms either need
the user to determine a suitable step size, or are computa-
tionally expensive. We now propose a modification to Ohtake
et al.’s algorithm [31] to make it more efficient. We simply
replace all the area weights in Eqn. (13) by 1, for reasons
explained shortly. Thus we have:
1
|FV(i)|
k∈FV(i)
or, equivalently,
1
|FV(i)|
k∈FV(i)
We now justify our modified algorithm. If a triangle Fkhas
a large area, there is generally a large distance between the
vertices of Fk. Vertices with larger distances from vertex Vi
should have a smaller influence on the position update for Vi.
Thus, we should give a lower weight to the projection pk(i)
of Vi onto Π?
which gives the same weight for pk(i) whether Ak is large
or small, seems more reasonable then Yagou et al.’s original
algorithm, which gives large weight to pk(i) when Akis large.
Our method is also simpler.
Note that Eqn. (19) can also be written as:
1
3|FV(i)|
j∈NV(i)
x?
i= xi+
?
n?
k(n?
k· (ck− xi)),
(19)
x?
i=
?
pk(i).
(20)
kwhen Ak is larger. Our modified algorithm,
x?
i= xi+
??
(i,j)∈∂Fk
n?
k(n?
k· (xj− xi)).
(21)
Comparing Eqn. (21) with Eqn. (11), it can be seen that our
algorithm is the same as Taubin’s algorithm with the choice
λ = 1/3|FV(i)|. This avoids the need for the user to choose λ
as in Taubin’s original algorithm. Going further, using Euler’s
formula, the average valence of a vertex on a triangular mesh
is six [32], and for speed, we can further replace |FV(i)| by 6.
Hence, we can simply choose λ = 1/18 in Taubin’s algorithm.
C. Convergence of vertex updating algorithms
We now prove the convergence of our vertex updating
algorithm. Because it is a special case of Ohtake et al.’s
algorithm [31], we first analyze the convergence of Ohtake
et al.’s algorithm (15). We start by rewriting the error function
e3(X) defined by Eqn. (15) as:
e3(X) = XTMX,
where X ∈ R3|V |is a vector formed by concatenating
{xi,i ∈ V }, and M ∈ R3|V |×3|V |is a block matrix with each
3 × 3 block defined by
Mij= −
k:(i,j)∈∂Fk
In the following, we use capital and small letters, respectively,
to distinguish a block and an element in a block matrix, i.e.,
we use mijto denote the {i,j} element of matrix M.
Obviously, M is a sparse symmetric positive semidefinite
matrix. Define a block diagonal matrix D whose 3×3 diagonal
block is given by:
?
We now have the following lemma:
Lemma 1: Matrix H = 2D − M is a symmetric positive
semidefinite matrix.
Proof: Matrix H is obviously symmetric. So, we only
need to prove that all its eigenvalues are nonnegative.
Let λ be one of its eigenvalues and Z its corresponding
eigenvector. Thus,
(2D − M)Z = λZ.
Without loss of generality, let the pthelement of Z be the
largest, i.e. zp≥ |zq|,∀q ?= p. Furthermore, suppose zpis in
the ithblock when Z is divided into blocks corresponding to
D and M. Then we have:
=
(22)
?
Akn?
kn?T
k, Mii= −
?
j∈NV(i)
Mij.
(23)
Dii= 3
k∈FV(i)
AkI3.
(24)
(25)
λ
?
6
q
(2dpq− mpq)zq
?
?
zp
=
k∈FV(i)
Ak−
?
?
q
mpqzq
zp
≥
6
k∈FV(i)
Ak−
q
|mpq|.
(26)
Consider ?n?
of the absolute values of any row of the matrix n?
greater than (1 +√3)/2. Further, by considering Eqn. (23),
we can show that
?
Substituting (27) into (26), we have λ ≥ 0.
Using Lemma 1, we can now prove the convergence of
Ohtake et al.’s algorithm [31].
Proposition 1: The vertex updating algorithm (15) is con-
vergent in the sense that the error e3(X) defined by Eqn. (15)
does not increase in each iteration, i.e., e3(X?) ≤ e3(X).
Proof: From (15), the new vertex position vector X?is
given by X?= (I −D−1M)X. Substituting this into e3(X?),
we can compute:
e3(X) − e3(X?)
=
XTMD−1(2D − M)D−1MX
k? = 1. It can easily be shown that the sum
kn?T
kis not
q
|mpq| ≤ 2(1 +
√3)
?
k∈FV(i)
Ak.
(27)
=
XT(2MD−1M − MD−1MD−1M)X
(28)

Page 7

7
(a) (b)(c)
(d) (e)(f)
Fig. 3. Denoising of a double-torus model (|V | = 2,686,|F| = 5,376). (a)
Original model, courtesy of MPII, (b) noisy model (Gaussian noise, standard
deviation = 0.2 mean edge length), (c) bilateral filtering result (n = 15), (d)
median filtering (n = 50), (e) fuzzy vector median filtering result (n1 =
30,n2= 20,σ = 0.3), (f) our result (n1= 30,n2= 20,T = 0.45).
From Lemma 1, we have e3(X) − e3(X?) ≥ 0.
Proposition 1 directly proves convergence of our vertex
updating algorithm.
Corollary 1: The vertex updating algorithm in (21) is con-
vergent in the sense that the error e1(X) defined by Eqn. (10)
does not increase in each iteration, i.e., e1(X?) ≤ e1(X).
Following a similar proof to that for Proposition 1, we can
also easily prove the convergence of Taubin’s algorithm.
Corollary 2: If λ ≤ 1/3|FV(i)|max, then the vertex up-
dating algorithm (11) is convergent in the sense that the error
e1(X) defined by Eqn. (10) does not increase in each iteration,
i.e., e1(X?) ≤ e1(X).
VI. RESULTS AND DISCUSSION
This Section demonstrates results of tests carried out on our
approach, and discusses optimal choice of parameters.
A. Denoising results
We now compare denoising results of several algorithms in-
cluding our new method. The next Section considers efficiency
of various methods.
The algorithms described in this paper have been imple-
mented in VC++.net. Several experiments were performed on
a PC with a 3.2GHz Intel Xeon CPU and 2.0GB of RAM. Both
synthetic and measured models were used in our experiments.
We first visually compare results obtained using our al-
gorithm with those from several other algorithms. We then
employ two numerical measures to compare the results in more
detail. In these comparisons, we show the best results obtained
for each approach after fine tuning the parameters. All models
have been rendered using flat shading.
Fig. 3 shows denoising results for a model with sharp
edges—the double-torus model. It can be seen that bilateral
filtering [13] tends to blur sharp edges. Median filtering [15]
preserves sharp edges, but makes flat areas uneven. In con-
trast, fuzzy vector median filtering [17] and our approach
(a)(b)(c)
(d)(e) (f)
Fig. 4. Denoising of a cylinder model (|V | = 404,|F| = 804). (a) Original
model, (b) noisy model (Gaussian noise, standard deviation = 0.2 mean edge
length), (c) bilateral filtering result (n = 5), (d) median filtering (n = 20),
(e) fuzzy vector median filtering resultt (n1 = 25,n2 = 20,σ = 0.4), (f)
our result (n1= 25,n2= 20,T = 0.4).
both preserve sharp edges and flat areas. Nevertheless, close
examination shows that our approach generates a smoother
final surface for this model. We also tested mean filtering [15]
and alpha-trimming filtering [16], but both methods blur sharp
edges, so we have not illustrated the corresponding results.
Fig. 4 shows the denoising results from a cylinder (first
faceted, then triangulated), which has both flat and curved
surfaces, and sharp edges. It can be seen that bilateral filtering
does not preserve sharp edges. Median filtering preserves the
sharp edges, but also introduces spurious additional sharp
edges. Fuzzy vector median filtering and our approach pre-
serve both sharp edges and the surface characteristics. There is
little visible difference between the latter two results, although
our method again seems to lead to a result more faithful to
the original surface.
Fig. 5 shows denoising results for the fandisk model. All
four approaches preserve most of the sharp edges. Bilateral
filtering and median filtering even preserve those sharp edges
with small angles between neighboring surfaces, but on the
other hand the surfaces in other areas are not particularly
smooth. Fuzzy vector median filtering and our approach
produce smooth surfaces and preserve most sharp edges, but
blur those sharp edges with small angles. Bilateral filtering
preserves sharp edges better on this model than on the previous
models. The reason seems to be due to the relatively small
noise level in this model, and few iterations of filtering are
required. We also performed a test on the fandisk model after
adding Gaussian noise with standard deviation = 0.2 mean
edge length. In this case, bilateral filtering blurs the sharp
edges if we try to achieve a reasonably smooth final surface.
Fig. 6 shows denoising results on a mesh model with details
at various sizes—the “iH” embossed Stanford Bunny Model.
All approaches do well apart from median filtering. Median
filtering has a tendency to enhance features in the noisy model,
and the resulting surface is not smooth. For this model, perhaps
bilateral filtering provides the best overall result, with the

Page 8

8
(a) (b)(c)
(d)(e)(f)
Fig. 5.
(a) Original model, courtesy of H. Hoppe. (b) noisy model (Guassian noise,
standard deviation = 0.1 mean edge length), (c) bilateral filtering result (n =
5), (d) median filtering result (n = 10), (e) fuzzy vector median filtering
result (n1= 10,n2= 10,σ = 0.3), (f) our result (n1= 10,n2= 10,T =
0.55).
Denoising of the fandisk model (|V | = 6,475,|F| = 12,946).
fuzzy vector median, and to a lesser extent our approach,
losing a little of the finer detail.
Figs. 7 and 8 show results of denoising two real, scanned
models. All approaches preserve the surface details to some
extent. Fuzzy vector median filtering and our approach seem to
produce smoother final surfaces than bilateral filtering and me-
dian filtering. Moreover, Fig. 7 shows that our method preserve
surface details better than the other methods. However, for the
face model shown in Fig. 8, areas near to the hole boundary are
not well denoised by our algorithm, or the fuzzy vector median
algorithm, when compared to the bilateral filtering method. We
do not give any special treatment to holes in our algorithm,
and future research should consider this problem. A possible
solution is to create virtual vertices as suggested by Desbrun
et al. [6].
Figs. 9 and 10 give further comparisons of our method to
bilateral filtering method when applied to two scanned models.
Comparing the forehead and the ears of the lion-dog shown
in Fig. 9(b) and (c), it can be seen that our method produces
a smoother surface than bilateral filtering, while comparing
the hair, and the pits on the tip of the nose and on the right-
hand side of the forehead in Figs. 9(d) and (e), one can see
that our method preserves detail better than bilateral filtering.
Comparing the ripples on the collar in Figs. 10(b) and (c),
and the wrinkles on the face in Figs. 10(d) and (e), further
verifies that our method preserves detail better. Considering
the lips, jaws and throat in Figs. 10(d) and (e) shows that our
method produces a similar smoothness to bilateral filtering in
this example.
Fig. 11 shows denoising results for the fandisk model under
addition of impulse noise (with similar properties to salt and
pepper noise used in image processing). Similar results are
obatined as in the case of Gaussian added noise.
The above comparisons show that the results from fuzzy
vector median filtering and our approach are generally visually
similar, and in most cases both produce better results than
(a)(b)(c)
(d)(e) (f)
Fig. 6.
34,834,|F| = 69,451). (a) Original model, courtesy of A. Belyaev, (b)
noisy model (Guassian noise, standard deviation = 0.2 mean edge length), (c)
bilateral filtering result (n = 5), (d) median filtering result (n = 15), (e)
fuzzy vector median filtering result (n1 = 5,n2 = 20,σ = 0.3), (f) our
result (n1= 5,n2= 20,T = 0.5).
Denoising of the “iH” embossed Stanford Bunny model (|V | =
TABLE I
L2ERROR COMPARISON (×10−3):
Model
Bilateral
Median
Fuzzy
our Method
double-torus
8.1082
1.7264
1.5017
1.2774
Cylinder
17.7088
8.7001
4.5274
4.4076
Fandisk
1.0778
0.9076
0.9329
1.0395
“iH” Bunny
1.6328
1.0707
1.2385
1.1481
either bilateral or median filtering. We next use two numerical
measures to compare our approach with other approaches,
particularly fuzzy vector median filtering.
Many metrics have been proposed in the literature to
compare the similarity (or difference) of two mesh surfaces .
These include 3D distance metrics [15], [33]–[36], tangential
error metrics [34], curvature error metrics [34], normal error
metrics [15], [17], [35], and combined methods [34].
We first use the L2vertex-based mesh-to-mesh error met-
ric [35] defined by Eqn. (29) to make a numerical comparison.
?
i∈V
Ev=
?
?
?
1
3?
i,T) is the L2distance between the new vertex
iand a triangle of the reference mesh T which is closest to
x?
considered. This numerical comparison generally, but not
invariably, is in agreement with the visual comparison results.
In general, our approach produces results almost as good as,
or better than, than those from other approaches, whether
compared visually or numerically.
Because the difference in the results between our approach
and the fuzzy vector median filtering is small and their main
difference is in the resulting face normals, we also use a
normal error metric to further compare them. The error metric
used is the mean square angular error (MSAE) [37], which is
k∈FAk
??
j∈FV(i)
Ajdist(x?
i,T)2,
(29)
where dist(x?
x?
i. Table I shows the Ev errors for the various algorithms

Page 9

9
(a)(b)(c)(d)(e)
Fig. 7.
median filtering result (n = 10), (d) fuzzy vector median filtering result (n1= 5,n2= 10,σ = 0.1), (e) our result (n1= 5,n2= 10,T = 0.9).
Denoising of the Moai model (|V | = 10,002,|F| = 20,000). (a) Original model, courtesy of Y. Ohtake, (b) bilateral filtering result (n = 5), (c)
(a) (b)(c)(d)(e)
Fig. 8.
median filtering result (n = 10), (d) fuzzy vector median filtering result (n1= 10,n2= 20,σ = 0.3), (e) our result (n1= 10,n2= 20,T = 0.65).
Denoising of a face model (|V | = 40,544,|F| = 76,522). (a) Original model, courtesy of J.-Y. Bouguet, (b) bilateral filtering result (n = 5), (c)
(a)(b)(c) (d)(e)
Fig. 9.
filtering result (n = 5), (c) front view of our result (n1= 5,n2= 10,T = 0.6), (d) back view of the bilateral filtering result, (e) back view of our result.
Denoising of the a lion-dog head model (|V | = 24,930,|F| = 50,000). (a) Original model, courtesy of Y. Ohtake, (b) front view of the bilateral
(a)(b)(c) (d) (e)
Fig. 10.
(c) front view of our result (n1= 5,n2= 10,T = 0.4), (d) zoom-in side view of the bilateral filtering result, (e) zoom-in side view of our result.
Denoising of the a scanned head model (|V | = 16,527,|F| = 32,369). (a) Original model (b) front view of the bilateral filtering result (n = 5),
also used in [17]. The definition of MSAE is
MSAE = E [∠(nd,n)],
where E is the expectation operator and ∠(nd,n) is the angle
(30)
between the denoised normal nd and the original normal n.
Note that we compare the normals produced by each approach
with those of the original model (before addition of noise).

Page 10

10
(a)(b) (c)(d)(e)
Fig. 11.
bilateral filtering result (n = 5), (c) median filtering result (n = 10), (d) fuzzy vector median filtering result (n1= 20,n2= 30,σ = 0.3), (e) our result
(n1= 20,n2= 30,T = 0.55).
Denoising a fandisk model with added impulse noise (noise added to 20% of the points, amplitude = 0.5 mean edge length). (a) Noisy model, (b)
05 1015 2025
n1
303540 45 50
0
0.02
0.04
0.06
0.08
0.1
0.12
0.14
0.16
0.18
0.2
MSAE
Fuzzy I:0.35
Fuzzy II:0.45
Our I:0.40
Our II:0.30
05 10152025
n1
3035 4045 50
0.01
0.02
0.03
0.04
0.05
0.06
0.07
0.08
0.09
0.1
0.11
MSAE
Fuzzy I:0.45
Fuzzy II:0.40
Our I:0.70
Our II:0.40
(a)(b)
05 10152025
n1
30 35404550
0
0.005
0.01
0.015
0.02
0.025
0.03
MSAE
Fuzzy I:0.15
Fuzzy II:0.25
Our I:0.80
Our II:0.70
05 10152025
n1
3035404550
0.01
0.02
0.03
0.04
0.05
0.06
0.07
0.08
MSAE
Fuzzy I:0.15
Fuzzy II:0.20
Our I:0.80
Our II:0.80
(c)(d)
Fig. 12.
used. Parameter values shown are σ or T, as appropriate. Graphs correspond to: (a) double-torus, (b) cylinder, (c) fandisk, and (d) “iH” Bunny.
Normal errors resulting from our approach and fuzzy vector median filtering, after n1iterations. I and II indicate the type of face neighbourhood
Fig. 12 shows the normal errors resulting from our approach
and fuzzy vector median filtering for several different models,
and how they vary with number of iterations of denoising.
Here, we use the distance function based on normal angle in
the fuzzy vector median filtering approach (see Eqn. (4)), as
it seems to generally yields better results. Overall, there is
little difference in normal errors produced by our approach
and fuzzy vector median filtering. However, closer analysis
shows that for models with many sharp edges our approach
usually results in lower normal error than the fuzzy vector
median filtering approach, but for models with mainly smooth
surfaces, the opposite is true. The minimal error produced by
our approach is usually smaller than that produced by the fuzzy
vector median: if the number of iterations is chosen suitably,
our approach tends to perform better than fuzzy vector median
filtering. We note that the threshold parameters shown in
Fig. 12 are different from those used previously in the visual
comparisons. There, we chose parameter values which resulted

Page 11

11
(a)(b)(c)
(d)(e)(f)
(d) (h)(i)
Fig. 13.
courtesy of Cyberware (|V | = 134,345,|F| = 268,686), (b) noisy model
(Guassian noise, standard deviation = 0.1 mean edge length), (c) denoised
result (n1 = 3,n2 = 10,T = 0.1). (d) Original dragon model, data from
Stanford University Computer Graphics Laboratory 3D scanning repository
(|V | = 437,645,|F| = 871,414), (e) noisy model (Guassian noise, standard
deviation = 0.2 mean edge length), (f) denoised result (n1 = 10,n2 =
15,T = 0). (g) Original Buddha model, courtesy of VCG-ISTI via the
AIM@SHAPE Shape Repository (|V | = 757,490,|F| = 1,514,962), (h)
noisy model (Guassian noise, standard deviation = 0.1 mean edge length), (i)
denoised result (n1= 3,n2= 10,T = 0.1).
Denoising results for large models. (a) Original Igea model, data
in best visual impression for a given fixed number of iterations,
while for Fig. 12 we have chosen the parameters which result
in the minimum MSAE value over all values of iterations
(n1= 1,...,50).
B. Computational cost
Firstly, we compare the time taken by the normal update
step of our algorithm with that by the fuzzy vector median
algorithm (again using a distance function based on angle).
Table II shows the CPU times recorded in our experiments. For
comparative purposes, we performed 50 iterations of normal
update for each algorithm, although it is not necessary in
practice to use so many iterations. Our approach is much faster
than the fuzzy vector median filtering method. When Type I
face neighbourhoods are used in both algorithms, our approach
is about 40 times faster than the fuzzy vector median filtering
method; for Type II face neighbourhoods the advantage is
about 12 times. Table II also shows a comparison of the
vertex update time taken by Yagou et al.’s method [15] and
our modified method, again for 50 iterations. Our modified
method is somewhat faster than the former.
Secondly, we compare in Table III the overall time taken
by our approach with that required by other approaches.
The values in parentheses are the numbers of iterations n
or n1,n2 we found necessary to satisfactorily denoise the
models. Overall, bilateral filtering is generally fastest, as it
requires less iterations. However, our approach requires a
time similar to that of the bilateral filtering approach, even
though requiring more iterations; sometimes, our approach is
even faster than bilateral filtering. The other approaches take
significantly longer.
Fig. 13 shows denoising results using our approach for large
models. The time taken for denoising these models are shown
in Table III. Our approach can rapidly and effectively denoise
large models.
Overall, our method can provide denoising results of a
quality comparable to the slowest of these methods, with
nearly the speed of the fastest.
C. Choice of parameters
We now briefly discuss the choice of parameters in our
algorithm. These are the threshold T, the number of normal
update iterations n1, and the number of vertex position update
iterations n2. We first give a heuristic rule for choice of
parameters, then provide an automatic method of choosing
parameters T and n2.
Fig. 14 shows MSAE for different choices of parameter T.
While smaller T usually yields lower normal errors for models
with smooth surfaces, for models with sharp edges (e.g. the
double-torus model), too small a value of T results in a large
error, especially as the number of iterations n1increases. Our
experiments indicate that T ∈ [0.4,0.6] is a good choice for
surfaces with sharp edges, and T ∈ [0,0.3] is a good choice
for smooth surfaces.
Fig. 14 also shows that models with larger noise levels
require more iterations of denoising, and models with sharp
edges require more iterations than those without. We can also
see that too many iterations can cause oversmoothing and
result in large normal errors. Our experiments used n1 ∈
[15,30] for sharp-edged models and n1∈ [3,10] for smooth
models.
In general, for models with higher noise level, the vertices
deviate further from their true positions, so n2should be larger.
Our experiments show that n2= 10 is generally enough for
models with Gaussian noise with 0.1 mean edge length of
standard deviation, and n2 = 20 enough for 0.2 mean edge
length of standard deviation.
The above suggestions usually allow suitable parameters to
be chosen interactively. However, we may require an automatic
algorithm. Fortunately, we have proved convergence of the
vertex updating algorithm in Section V-C, and we can use this
to automatically determine n2. We only need to set a maximum
number of iterations n2 and a precision. The algorithm can
terminate the vertex updating process before the maximum n2
iterations when the absolute error of e1(X) or the relative error
between two iterations reaches the required precision.
To determine T automatically, we follow the suggestion of
Fleishmann et al. [13]. The user first selects a small region
on the surface that is expected to be smooth, and then the
minimum value of the dot product of normals of adjacent faces
in this region can be computed and used as the threshold T.

Page 12

12
TABLE II
TWO-STAGE TIME COMPARISON (SECONDS):
Model
Vertices
Triangles
Our method
Fuzzy
Our method
Fuzzy
Our method
Yagou
Fandisk
6,475
12,946
0.235
9.391
0.11
1.375
0.078
0.125
“iH” Bunny
34,834
69,451
1.438
48.406
0.609
7.297
0.922
1.14
Igea
134,345
268,686
5.609
196.531
2.516
28.421
5.047
6.375
Dragon
437,645
871,414
19.25
677.719
8.593
91.797
9.359
11.031
Buddha
757,490
1,514,962
32.375
1263.06
14.313
177.906
21.969
29.094
Normal Update
Type I neighbourhoods
Normal Update
Type II neighbourhoods
Vertex Position Update
TABLE III
OVERALL TIME COMPARISON (SECONDS, FOR GIVEN NUMBERS OF ITERATIONS):
Fandisk
0.046
(5)
0.281
(10)
1.891
(10, 10)
0.078
(10, 10)
“iH” Bunny
0.313
(5)
2.594
(15)
5.141
(5, 20)
0.515
(5, 20)
Igea
1.313
(5)
7.25
(10)
12.641
(3, 10)
1.407
(3, 10)
Dragon
3.75
(5)
33.219
(15)
140.438
(10, 15)
6.672
(10,15)
Buddha
7.094
(5)
39.047
(10)
70.093
(3, 10)
6.406
(3,10)
Bilateral
Median
Fuzzy
Our
method
0510152025
n1
3035 40 4550
0
0.2
0.4
0.6
0.8
1
1.2
1.4
1.6
1.8
2x 10
−3
MSAE
T:0.3
T:0.4
T:0.5
T:0.6
T:0.7
05 1015 2025
n1
30354045 50
0
0.02
0.04
0.06
0.08
0.1
0.12
0.14
0.16
0.18
MSAE
T:0.3
T:0.4
T:0.5
T:0.6
T:0.7
(a)(b)
05101520 25
n1
3035404550
0.005
0.01
0.015
0.02
0.025
0.03
0.035
0.04
0.045
0.05
0.055
MSAE
T:0.0
T:0.1
T:0.2
T:0.3
T:0.4
0510 152025
n1
3035404550
0
0.02
0.04
0.06
0.08
0.1
0.12
MSAE
T:0.0
T:0.1
T:0.2
T:0.3
T:0.4
(c)(d)
Fig. 14.
length, (b,d) noise standard deviation = 0.2 mean edge length.
Normal error for different choice of parameter T. (a,b): double-torus model, (c,d) dragon model; (a,c) noise standard deviation = 0.05 mean edge

Page 13

13
VII. CONCLUSION
Many mesh denoising methods have been proposed. Some
can both remove noise and preserve mesh features effec-
tively. However, most of these methods are computationally
expensive, especially if real-time interactive mesh processing
is desired. Through analysis of existing algorithms, we have
been able to propose a fast and effective feature-preserving
denoising approach.
Experiments show that our approach is as fast as the
bilateral filtering approach [13]: e.g. it can denoise the Bud-
dha model of 1.5 million triangles within 7s. However, our
approach can preserve sharp edges better than the bilateral
filtering approach, providing a final surface quality compa-
rable to that achieved by the fuzzy vector median filtering
approach [17], while being significantly faster.
We have conducted many further experiments than space
permits to demonstrate in this paper. Most of the models
shown here have uniform triangle size; we have found that
our algorithm is also suitable for models with nonuniform
triangles, even though we do not take the triangle area into
account in our algorithm. As our analysis here suggests,
area-weighted algorithms sometimes give worse results than
algorithms which ignore triangle areas.
We have also experimented with a one-stage iteration
scheme (Step 1+Step 2)nusing our algorithm. Experimental
results agreed with our analysis in Section I, i.e., that to obtain
a given degree of denoising, we usually need max(n1,n2) <
n, and so the two-stage iteration scheme is faster than the
one-stage scheme.
Although our algorithm is simple and efficient for feature-
preserving mesh denoising, it also has some problems in
common with other algorithms. For example, it cannot ef-
fectively deal with meshes with lots of holes. If the normal
denoising results are not very good due to undersmoothing or
oversmoothing, the vertex updating step may result in non-
optimal positions, causing some geometric inconsistencies,
such as mesh folding, self intersections and poorly-shaped
triangles. Future research is needed to resolve these problems.
Also, convergence analysis is needed on the normal filtering
algorithms.
ACKNOWLEDGMENT
We are grateful to the anonymous reviewers for their valu-
able comments. This work was supported by EPSRC Grant
EP/C007972 and NSFC Grant 60674030.
REFERENCES
[1] T. Tasdizen, R. Whitaker, P. Burchard, and S. Osher, “Geometric surface
smoothing via anisotropic diffusion of normals,” in Proceedings of the
Conference on Visualization 2002.
125–132.
[2] J. Shen, B. Maxim, and K. Akingbehin, “Accurate correction of sur-
face noises of polygonal meshes,” International Journal for Numerical
Methods in Engineering, vol. 64, no. 12, pp. 1678–1698, 2005.
[3] D. A. Field, “Laplacian smoothing and delaunay triangulations,” Com-
munications in Numerical Methods in Engineering, vol. 4, pp. 709–712,
1988.
[4] J. Vollmer, R. Mencl, and H. M¨ uller, “Improved laplacian smoothing of
noisy surface meshes,” Computer Graphics Forum, vol. 18, no. 3, pp.
131–138, 1999.
IEEE Computer Society, 2002, pp.
[5] G. Taubin, “A signal processing approach to fair surface design,” in
SIGGRAPH’95 Conference Proceedings, 1995, pp. 351–358.
[6] M. Desbrun, M. Meyer, P. Schr¨ oder, and A. H. Barr, “Implicit fairing
of irregular meshes using diffusion and curvature flow,” in Proceedings
of SIGGRAPH’99, 1999, pp. 317–324.
[7] B. Kim and J. Rossignac, “Geofilter: Geometric selection of mesh filter
parameters,” Computer Graphics Forum, vol. 24, no. 3, pp. 295–302,
2005.
[8] U. Clarenz, U. Diewald, and M. Rumpf, “Anisotropic geometric dif-
fusion in surface processing,” in Proceedings of the Conference on
Visualization 2000.IEEE Computer Society, 2000, pp. 397–405.
[9] M. Desbrun, M. Meyer, P. Schr¨ oder, and A. H. Barr, “Anisotropic
Feature-Preserving denoising of height fields and bivariate data,” in
Graphics Interface’2000 Proceedings, 2000, pp. 145–152.
[10] C. L. Bajaj and G. Xu, “Anisotropic diffusion of surfaces and functions
on surfaces,” ACM Trans. Graphics, vol. 22, no. 1, pp. 4–32, 2003.
[11] K. Hildebrandt and K. Polthier, “Anisotropic filtering of non-linear
surface features,” Computer Graphics Forum, vol. 23, no. 3, pp. 391–
400, 2004.
[12] T. R. Jones, F. Durand, and M. Desbrun, “Non-iterative, feature-
preserving mesh smoothing,” ACM Transactions on Graphics, vol. 22,
no. 3, pp. 943–949, 2003.
[13] S. Fleishman, I. Drori, and D. Cohen-Or, “Bilateral mesh denoising,”
ACM Transactions on Graphics, vol. 22, no. 3, pp. 950–953, 2003.
[14] G. Taubin, “Linear anisotropic mesh filtering,” IBM Research Report
RC22213(W0110-051), IBM T.J. Watson Research Center, October
2001.
[15] H. Yagou, Y. Ohtake, and A. G. Belyaev, “Mesh smoothing via mean and
median filtering applied to face normals,” in Proceedings of Geometric
Modeling and Processing, 2002, pp. 124–131.
[16] H. Yagou, Y. Ohtake, and A. G. Belyaev, “Mesh denoising via iterative
alpha-trimming and nonlinear diffusion of normals with automatic
thresholding,” in Computer Graphics International 2003 (CGI’03),
2003, pp. 28–34.
[17] Y. Shen and K. E. Barner, “Fuzzy vector median-based surface smooth-
ing,” IEEE Trans. Visualization and Computer Graphics, vol. 10, no. 3,
pp. 252–265, 2004.
[18] C.-Y. Chen and H.-Y. Cheng, “A sharp dependent filter for mesh
smoothing,” Computer Aided Geometric Design, vol. 22, pp. 376–391,
2005.
[19] D. Nehab, S. Rusinkiewicz, J. Davis, and R. Ramamoorthi, “Efficiently
combining positions and normals for precise 3D geometry,” ACM
Transactions on Graphics (Proc. SIGGRAPH), vol. 24, no. 3, pp. 536–
543, 2005.
[20] J. R. Diebel, S. Thrun, and M. Br¨ unig, “A bayesian method for probable
surface reconstruction and decimation,” ACM Trans. Graphics, vol. 25,
no. 1, pp. 39–59, 2006.
[21] M. Alexa, J. Behr, D. Cohen-Or, S. Fleishman, D. Levin, and C. T. Silva,
“Point set surfaces,” in Proceedings of the conference on Visualization
’01. IEEE Computer Society, 2001, pp. 21–28.
[22] L. Kobbelt and M. Botsch, “A survey of point-based techniques in
computer graphics,” Computers & Graphics, vol. 28, no. 6, pp. 801–
814, 2004.
[23] A. Adamson and M. Alexa, “Anisotropic point set surfaces,” in Proceed-
ings of the 4th international conference on Computer graphics, virtual
reality, visualisation and interaction in Africa.
7–13.
[24] S. Fleishman, D. Cohen-Or, and C. T. Silva, “Robust moving least-
squares fitting with sharp features,” ACM Transactions on Graphics,
vol. 24, no. 3, pp. 544–552, 2005.
[25] Y. Ohtake, A. Belyaev, and M. Alex, “Sparse low-degree implicit sur-
faces with applications to high quality rendering, feature extraction, and
smoothing,” in Third Eurographics Symposium on Geometry Processing,
2005, pp. 149–158.
[26] T. Mashiko, H. Yagou, D. Wei, Y. Ding, and G. Wu, “3D triangle mesh
smoothing via adaptive MMSE filtering,” in Proceedings of the Fourth
International Conference on Computer and Information Technology
(CIT’04).IEEE Computer Society, 2004, pp. 734–740.
[27] Y. Yu, K. Zhou, D. Xu, X. Shi, H. Bao, B. Guo, and H. Shum,
“Mesh editing with poisson-based gradient field manipulation,” ACM
Transactions on Graphics, vol. 23, no. 3, pp. 644–651, 2004.
[28] M. Botsch, D. Bommes, and L. Kobbelt, “Efficient linear system solvers
for mesh processing,” vol. 3604, 2005, pp. 62–83.
[29] L. Shi, Y. Yu, N. Bell, and W.-W. Feng, “A fast multigrid algorithm for
mesh deformation,” ACM Transactions on Graphics, vol. 25, no. 3, pp.
1108–1117, 2006.
ACM Press, 2006, pp.

Page 14

14
[30] Y. Ohtake, A. Belyaev, and H.-P. Seidel, “Mesh smoothing by adaptive
and anisotropic gaussian filter applied to mesh normals,” in Vision,
Modeling, and Visualization 2002, 2002, pp. 203–210.
[31] Y. Ohtake, A. Belyaev, and I. Bogaevski, “Mesh regularization and
adaptive smoothing,” Computer-Aided Design, vol. 33, no. 11, pp. 789–
800, 2001.
[32] O. Sorkine, D. Cohen-Or, R. Goldenthal, and D. Lischinski, “Bounded-
distortion piecewise mesh parameterization,” in Proceedings of the
Conference on Visualization 2002.
355–362.
[33] P. Cignoni, C. Rocchini, and R. Scopigno, “Metro: Measuring error on
simplified surfaces,” Computer Graphics Forum, vol. 17, no. 2, pp. 167–
174, 1998.
[34] S.-J. Kim, S.-K. Kim, and C.-H. Kim, “Discrete differential error metric
for surface simplification,” in Proceedings of the 10th Pacific Conference
on Computer Graphics and Application (PG’02).
Society, 2002, pp. 276–283.
[35] A. Belyaev and Y. Ohtake, “A comparison of mesh smoothing methods,”
in Proceedings of Israel-Korea Bi-National Conference on Geometric
Modeling and Computer Graphics, 2003, pp. 83–87.
[36] P. Rondao Alface, M. De Craene, and B. Macq, “Three-dimensional
image quality measurement for the benchmarking of 3d watermarking
schemes,” Proceedings of SPIE, vol. 5681, pp. 230–240, 2005.
[37] A. Nehorai and M. Hawkes, “Performance bounds for estimatin vector
systems,” IEEE Trans. Signal Processing, vol. 48, no. 6, pp. 1737–1749,
2000.
IEEE Computer Society, 2002, pp.
IEEE Computer
Xianfang Sun received his BSc degree in Electrical
Automation from Hubei University of Technology
in 1984. He received his MSc and PhD degrees in
Control Theory and its Applications from Tsinghua
University in 1991, and the Institute of Automation,
Chinese Academy of Sciences in 1994, respectively.
He joined Beihang University (BUAA) as a Post-
Doctorial Fellow, where he became an Associate
Professor in 1997 and a Professor in 2001. Cur-
rently, he is on leave from Beihang University and
is a Research Associate at Cardiff University. His
research interests include computer vision and graphics, pattern recognition
and artificial intelligence, system identification and filtering, fault diagnosis
and fault-tolerant control. He has completed many research projects and
published over 50 papers. He is on the editorial board of “Acta Aeronautica
et Astronautica Sinica”. He is also a member of the Committee of Technical
Process Failure Diagnosis and Safety, Chinese Association of Automation.
Paul L. Rosin received the B.Sc. degree in com-
puter science and microprocessor systems in 1984
from Strathclyde University, Glasgow, U.K., and
the Ph.D. degree in information engineering from
City University, London, U.K., in 1988. He was a
Research Fellow at City University, developing a
prototype system for the Home Office to detect and
classify intruders in image sequences. He worked
on the Alvey project “Model-Based Interpretation
of Radiological Images” at Guy’s Hospital, London,
before becoming a Lecturer at Curtin University of
Technology, Perth, Australia, and later a Research Scientist at the Institute
for Remote Sensing Applications, Joint Research Centre, Ispra, Italy. He then
returned to the U.K., becoming a Lecturer at the Department of Information
Systems and Computing, Brunel University, London. Currently, he is a Senior
Lecturer at the School of Computer Science, Cardiff University, Cardiff, U.K.
His research interests include the representation, segmentation, and grouping
of curves, knowledge-based vision systems, early image representations, low
level image processing, machine vision approaches to remote sensing, medical
and biological image analysis, and the analysis of shape in art and architecture.
Ralph R. Martin has been working in the field
of CADCAM since 1979. He obtained his PhD in
1983 from Cambridge University for a dissertation
on “Principal Patches”, and since then has worked
his way up from Lecturer to Professor at Cardiff
University. He has published over 170 papers and
10 books covering such topics as solid modelling,
surface modelling, intelligent sketch input, vision
based geometric inspection, geometric reasoning and
reverse engineering. He is a Fellow of the Institute
of Mathematics and its Applications, and a Member
of the British Computer Society. He is on the editorial boards of “Computer
Aided Design”, the “International Journal of Shape Modelling”, the “Inter-
national Journal of CADCAM”, and “Computer-Aided Design and Applica-
tions”. He has also been active in the organisation of many conferences.
Frank C. Langbein (M’00) received a Diploma
in Mathematics from the University of Stuttgart in
1998. He obtained his PhD in 2003 from Cardiff
University for a dissertation on “Beautification of
Reverse Engineered Geometric Models”. Since then
he has been a Lecturer in Computer Science at
Cardiff University. His research interests in geomet-
ric modelling include detection and representation
of design intent in geometric models, geometric
constraints, mesh processing, free-form surfaces and
reverse engineering. He is also interested in quantum
modelling and quantum information and works on simulation, identification
and control of quantum systems. He is a member of the American Mathemat-
ical Society and the IEEE.