ArticlePDF Available

AN EFFECTIVE QUAD-DOMINANT MESHING METHOD FOR UNORGANIZED POINT CLOUDS

Authors:

Abstract and Figures

To perform quad meshing on raw point clouds, existing algorithms usually require a time-consuming parameterization or Voronoi space partition process. In this paper, we propose an effective method to generate quad-dominant meshes directly from unorganized point clouds. In the proposed method, we first apply Marinov's curvature tensor optimization to the input point cloud to reduce the umbilical regions in order to obtain a smooth curvature tensor. We then propose an efficient marching scheme to extract the curvature lines with controllable density from the point cloud. Finally, we apply a specialized K-Dimension (KD) tree structure, which converts the nearest neighbor searching problem into a sorting problem, to efficiently estimate the intersections of curvature lines and recover the topol-ogy of the quad-dominant meshes. We have tested the proposed method on different point clouds. Our results show that the proposed method produces good quality meshes with high computational efficiency and low memory requirement.
Content may be subject to copyright.
An effective quad-dominant meshing method for unorganized
point clouds
q
Xufang Pang
a,b
, Zhan Song
b,c,
, Rynson W.H. Lau
a
a
Department of Computer Science, City University of Hong Kong, Hong Kong
b
Shenzhen Institutes of Advanced Technology, Chinese Academy of Sciences, Shenzhen, China
c
The Chinese University of Hong Kong, Hong Kong
article info
Article history:
Received 21 January 2013
Received in revised form 6 November 2013
Accepted 29 November 2013
Available online 12 December 2013
Keywords:
Quad-dominant meshes
Curvature tensor
Curvature lines
Point clouds
abstract
To perform quad meshing on raw point clouds, existing algorithms usually require a time-
consuming parameterization or Voronoi space partition process. In this paper, we propose
an effective method to generate quad-dominant meshes directly from unorganized point
clouds. In the proposed method, we first apply Marinov’s curvature tensor optimization
to the input point cloud to reduce the umbilical regions in order to obtain a smooth curva-
ture tensor. We then propose an efficient marching scheme to extract the curvature lines
with controllable density from the point cloud. Finally, we apply a specialized K-Dimension
(KD) tree structure, which converts the nearest neighbor searching problem into a sorting
problem, to efficiently estimate the intersections of curvature lines and recover the topol-
ogy of the quad-dominant meshes. We have tested the proposed method on different point
clouds. Our results show that the proposed method produces good quality meshes with
high computational efficiency and low memory requirement.
Ó2013 Elsevier Inc. All rights reserved.
1. Introduction
Quadrilateral meshing has been one of the most popular
geometric shape description methods in computer graphics
and surface modeling. For a given number of mesh ele-
ments, if the mesh anisotropy follows the principal direc-
tions of the curvature tensor, the quadrilateral mesh could
be the best approximation of a smooth surface [1,2]. Due
to this appealing tensor-product nature of quad-dominant
meshes, anisotropic quad meshing techniques are of great
interests in many applications, such as computer aided geo-
metric design, reverse engineering of geometry models and
computer simulation. Significant progress in quadrilateral
mesh generation and processing has been reported in re-
cent years [3–5].
1.1. Related work
Numerous works have contributed to quad-dominant
meshing on triangular meshes. In [4], Alliez et al. generate
quad-dominant meshes by intersecting curvature lines ex-
tracted from a global parameterization domain. In [5],
Marinov and Kobbelt improve Alliez’s algorithm by apply-
ing local parameterization so that it can be applied to sur-
faces with arbitrary genus. Ray et al. [6] propose a
periodic global parameterization-based approach to build
a quadrilateral mesh by tracking the isolines in the param-
eterization domain. In [7], Kalberer et al. convert the trian-
gular meshes into anisotropic quadrilaterals under the
principal curvature frames via the proposed global param-
eterization method. Bommes et al. [8] formulate the cross
field construction and global parameterization as a
mixed-integer optimization problem to produce high qual-
ity quadrilateral meshes. All these works demonstrate that
1524-0703/$ - see front matter Ó2013 Elsevier Inc. All rights reserved.
http://dx.doi.org/10.1016/j.gmod.2013.11.004
q
This paper has been recommended for acceptance by Pierre Alliez and
Peter Lindstrom.
Corresponding author at: Shenzhen Institutes of Advanced Technol-
ogy, Chinese Academy of Sciences, Shenzhen, China.
E-mail addresses: xpang4@cityu.edu.hk (X. Pang), zhan.song@
siat.ac.cn (Z. Song), rynson.lau@cityu.edu.hk (R.W.H. Lau).
Graphical Models 76 (2014) 86–102
Contents lists available at ScienceDirect
Graphical Models
journal homepage: www.elsevier.com/locate/gmod
the parameterization-based approach can deal with quad-
dominant remeshing of triangular meshes effectively.
On the other hand, there are only a limited number of
works that focus on quad-dominant meshing of point
clouds. In [9], Pietroni et al. propose a quad meshing meth-
od based on global parameterization. It represents the sur-
face by height maps over a set of planes. In [10],
Kalogerakis et al. extend Marinov’s anisotropic polygonal
remeshing method [5] to the point cloud domain. Since
the topological information is not available from raw point
clouds, a global Voronoi space partitioning step is needed
before calculating intersections of curvature lines. In [11],
Li et al. present an algorithm for quad-dominant meshing
of unorganized point clouds, which is applicable to the sur-
face of arbitrary shapes. It first applies periodic global
parameterization [6] to the point clouds and then a local
Delaunay triangulation to smooth the calculated principal
directions. Although these point cloud-based quad-domi-
nant meshing methods can produce high quality quad
meshes, the computational cost and memory requirements
are relatively high due to the time consuming parameteri-
zation or Voronoi space partitioning processes.
Our objective in this work is to improve the efficiency of
quad-dominant meshing algorithms for raw point clouds.
The main contributions of our work include:
Instead of performing the parameterization and trian-
gulation steps, a novel marching method is proposed
to control the resolution of the generated curvature
lines in a distinct and definite way.
By constructing a specialized KD-tree structure over the
curvature lines, the nearest neighbor searching problem
can be converted into a sorting problem. Thus, the inter-
sections and topology of the curvature lines can be
retrieved efficiently.
Since the curvature lines may not exactly intersect with
each other in 3D space, a new approach is proposed to
estimate the intersections of curvature lines by comput-
ing the common perpendicular lines of different kinds
of line segments.
We have tested the proposed method using various
unorganized point clouds. The results show that satisfac-
tory quad-dominant meshes at multi-resolution can be ob-
tained with high efficiency and lower memory
requirement. Fig. 1 shows a quad-dominant meshing result
of a point cloud of the Squirrel model.
1.2. Overview of the proposed method
We use Fig. 2 as an example to illustrate the workflow
and the major steps of the proposed method. With an
unorganized point cloud as input, our method can be sum-
marized as follows:
(1) The oriented normals of the point cloud are first esti-
mated (Fig. 2a). A locally smooth manifold patch is
fitted for each point via the Moving Least Squares
(MLS) method [12,13] (Fig. 2b). By building a
second-order tensor over the local surface approxi-
mation, the curvature tensors weighted with a
confidence term can be calculated. Then, the curva-
ture tensors can be optimized via a propagation
operator (Fig. 2c).
(2) The curvature lines are integrated directly on the
point cloud with adaptive step size and line intervals
using the proposed marching method (Fig. 2d).
(3) The intersections of curvature lines can be calcu-
lated directly in 3D space (Fig. 2e). The quad-domi-
nant meshes over the point cloud can then be built
via the half-edge structures (Fig. 2f).
The rest of this paper is organized as follows. Section 2
introduces methods for estimating and optimizing curva-
ture tensors from point cloud data. Section 3shows how
the curvature lines can be extracted from the estimated
curvature tensors. Section 4then presents the proposed
quad-dominant meshing method. Section 5discusses some
experimental results. Finally, Section 6concludes this work
and suggests possible future works.
2. Estimation and optimization of curvature tensors
Given an unorganized point cloud Pas:
P¼fp
i
:i2f1;...;Ng;p
i
2R
3
1Þ
the moving least squares (MLS) method is first adopted to
fit a smooth patch over the neighbors of each point p
i
.In
this paper, a paraboloid surface constructed in a local
coordinate with the z-axis as the symmetry axis is used
to fit each local area for its natural anisotropic attribute
[14].
2.1. Polynomial surface fitting
For each point p
i
, we compute a reference plane D
i
and a
normal n
i
by performing a weighted covariance analysis
over the r-neighborhood of p
i
. We denote the average sta-
tion distance of P(i.e., the average distance between every
point in Pand its kneighbors) as
j
. The value of kis typi-
cally set between 5 to 8, and ris empirically set to 10
j
.
An alternative simplified method is to select npoints from
the point set randomly and then calculate
j
as follows:
j
¼X
n
i¼0
X
k
m¼0
jjp
i
p
i
m
jj
!
=k
!
=nð2Þ
Fig. 1. Quad-dominant meshes (right) produced by applying the pro-
posed method on a point cloud of the squirrel model (left).
X. Pang et al. / Graphical Models 76 (2014) 86–102 87
As the computed surface normal n
i
may point to opposite
directions, a surface normal adjustment algorithm as de-
scribed in [15,16] is applied to make sure that all surface
normals point to the ‘‘out’’ direction. Then, a local coordi-
nate frame on D
i
can be defined as {p
i
,u,
v
,n
i
}, where p
i
is the origin and n
i
is the normalized z-axis vector.
By transforming p
i
’s neighbors into a computed local
frame, a local MLS polynomial g
i
of degree 2 can be approx-
imated by minimizing the distance between the fitting
points and the original point sets in least squares sense as:
g
i
ðu;
v
Þ¼au
v
þbu
2
þc
v
2
ðu;
v
Þ2½@; @
2
ð3Þ
For any point qnearby D
i
, its projection on g
i
can be com-
puted in the global coordinate and expressed as:
p
i
þðu
q
;
v
q
;gðu
q
;
v
q
ÞÞ
2.2. Estimation of curvature tensors
The curvature tensor matrix for each point p
i
can be
computed as the Hessian matrix of g
i
:
Hðg
i
Þ¼ h
11
h
12
h
12
h
22
¼
r
ð
r
g
i
Þ¼
@g
i
@u@u
@g
i
@u@
v
@g
i
@u@
v
@g
i
@
v
@
v
¼2ba
a2c
ð4Þ
The principal curvatures and directions can be calculated
from the Eigenvalues and Eigenvectors of the Hessian ma-
trix H(g
i
) directly [17]. As shown in Fig. 3, the computed
curvature tensors match well with the surface shape.
Since T
max
and T
min
are everywhere orthogonal except
for the umbilical regions, we only need to compute one
of the curvature direction fields. The other direction field
can then be obtained by computing the gradient field.
2.3. Confidence estimation and curvature tensor optimization
The curvature tensors computed from the raw point
cloud can be disturbed by surface noise, and unexpected
umbilical points where the principal directions are not
well defined. Thus, an optimization of curvature tensors
Fig. 2. Workflow of the proposed quad-dominant meshing algorithm. (a) The input raw point cloud rendered with surface normal; (b) The result of surface
fitting and calculated curvature; (c) The calculated curvature tensors; (d) Integration of the curvature lines; (e) Intersections of curvature lines; (f) Quad-
dominant meshing results on the raw point cloud.
Fig. 3. The computed curvatures and curvature tensors on a 3D point
cloud hand model. (a) indicates the color mapping to the magnitude of
the principal curvatures. (b) and (c) show the maximum and minimum
principal curvatures and their corresponding directions, respectively. The
line segments denote the principal directions. (For interpretation of the
references to colour in this figure legend, the reader is referred to the web
version of this article.)
88 X. Pang et al. / Graphical Models 76 (2014) 86–102
is required before the quad meshing process. According to
[17,18], a point in the second-order tensor field is defined
as an umbilical point if there are at least two Eigenvalues
that are the same. Referring to the Hessian matrix H(g
i
)
in Eq. (4), the umbilical points should satisfy:
h
11
ðp
i
Þh
22
ðp
i
Þ¼0
h
12
ðp
i
Þ¼0
ð5Þ
Thus, the confidence of the principal direction for each
point can be computed as:
w¼ðh
11
h
22
Þ
2
þh
2
12
¼ð2b2cÞ
2
þa
2
ð6Þ
The curvature tensor can be optimized by propagating the
curvature directions from high confidence regions to low
confidence regions [5]. The weighted coefficients in the
discrete Laplacian operator can be expressed as:
Hðg
i
Þ
kþ1
¼w
i
dHðg
i
Þ
k
þ1w
i
d

X
j2NbðiÞ
w
j
Hðg
j
Þ
k
X
j2NbðiÞ
w
j
ð7Þ
where H(g
i
)
k
is the curvature tensor matrix or the Hessian
matrix at point p
i
at the k-th smoothing iteration. dis a
threshold for the confidence, which defines a mask for
the smoothing operator. Only for those points with confi-
dence less than d, their curvature tensors will be smoothed.
Since the principal directions in the regions with low con-
fidence do not align well with the surface shape as shown
in Fig. 4a, they are not suitable for guiding the mesh edge
generation step. As shown in Fig. 4b, the proposed operator
retains high confidence principal directions and propa-
gates the curvature tensors from the anisotropic areas to
the isotropic areas. Thus, the low-confidence regions and
umbilical points are consequently reduced.
3. Extraction of curvature lines
The curvature lines are used to align mesh edges. They
play an important role in quad-dominant meshing. There
are two key problems in the extraction of curvature lines,
preserving the features and controlling the density of the
generated flow lines. In our method, the tracing process
starts by building a priority queue of seed points selected
from the point cloud. With a pre-defined step size and
the proposed labeling scheme, the lines of maximum
and minimum curvatures over the whole dataset can be
determined.
3.1. Feature preservation
To preserve the surface features, such as valleys and
ridges, a priority queue of seed points is constructed before
the tracing process. The estimated confidence for each
point indicates not only the stability of its principal direc-
tions, but also its impossibility to be an umbilical point
(i.e., most unlikely to be considered as a potential line
seed). As shown in Fig. 5a, the computed confidence of
each point indicates the ratio of its principal curvatures.
Surface features such as ridges and valleys have high con-
fidences. In contrast, umbilical points and points in flat re-
gions have low confidences. To preserve the underlying
features, a priority queue is constructed by selecting the
seed points with higher confidence before the extraction
of curvature lines. Fig. 5b shows the curvature lines gener-
ated from the points with confidence value w> 20 in the
priority queue.
3.2. Tracing of flow lines
The tracing of flow lines is a crucial step in the proposed
algorithm. Generally, existing methods for tracing curva-
ture lines can be classified into two types:
(1) Methods based on global parameterization and
streamline placement techniques [19], e.g., [7,8,20].
In these methods, the theoretical distances between
curvature lines can be well approximated in the para-
metric domain due to its conformal characteristic.
Fig. 4. Optimization of curvature tensors on the 3D point cloud hand
model. (a) Confidence distribution before curvature tensor optimization
and the computed local curvature lines; (b) Confidence distribution after
curvature tensor optimization and the computed local curvature lines.
Fig. 5. A priority queue is constructed to preserve features in the
generation of curvature lines. (a) The upper Venus model shows the
larger absolute principal curvature of each point, and the lower model
shows the magnitude of the computed confidence of each point; (b)
Curvature lines generated from the points with confidence w> 20. The
blue and red colors indicate the maximum and minimum curvature lines,
respectively. (For interpretation of the references to colour in this figure
legend, the reader is referred to the web version of this article.)
X. Pang et al. / Graphical Models 76 (2014) 86–102 89
However, there are still challenges for these methods
to handle surfaces with arbitrary genus. In addition,
global parameterization is a computationally
expensive process.
(2) Methods based on triangulation or Voronoi space
partitioning, e.g., [5,10,11]. For the triangular
meshes or models partitioned by Voronoi diagrams,
a list of all previously computed line segments can
be preserved in each mesh patch or Voronoi cell.
This allows the retrieval of neighboring segments
more conveniently. However, similar to the global
parameterization-based methods, the triangulation
or space partitioning process on point clouds is also
computationally expensive.
Density detection of curvature lines is important as it
affects the efficiency of the tracing algorithm. In this work,
to improve the tracing efficiency, we propose a marching
algorithm to control the density of curvature lines by label-
ing the traveling path. To trace a flow line, the first sample
point is the seed point popped from the priority queue. It is
traced along all principal directions, d
e
{T
max
,T
max
,T
min
,
T
min
}.
Let S
i
={s
1
,...,s
k
,...,s
n
} be the curve being generated,
where s
k
is the k-th sample point, s
k
=s
k1
+
x
d
k1
,
x
indicates a pre-defined step size, and d
k1
is the principal
direction of s
k1
. As the computed s
k
may not belong to
the original point set, by projecting the neighboring points
of s
k
to the local fitting surface, the new s
k
can be calculated
from the projections associated with Gaussian weights. By
searching for the nearest point p
x
of s
k
on point cloud P, the
principal direction d
k
of s
k
can be computed.
Since our meshing method is directly applied on a raw
point cloud, the normal orientations of the point cloud
need to be consistent. Hence, for each vertex on the curva-
ture lines, its surface normal can be estimated with refer-
ence to its neighboring points. In the tracing process, we
first set the principal directions within a local region of ra-
dius dto the same signs. After that, the neighboring points
of the newly updated flow point within radius dcan be la-
beled to serve as the density control. In the implementa-
tion, for all the neighbors of the seed point, only the
points within the semi-sphere along current tracing direc-
tion are labeled as shown in Fig. 6. Each flow line S
i
stops if
one of the following conditions is satisfied:
If all the local neighbors of the current flow point have
been labeled.
If a flow line reaches the boundary of the point cloud,
i.e., no local neighbors can be found.
With the above stopping conditions, the density of cur-
vature lines can be well controlled during the tracing
process.
3.3. Extracting the curvature lines
With the above two problems solved, our method for
extracting the curvature lines is as follows. We first com-
pute the lines of maximum and minimum curvatures inde-
pendently, and add the corresponding sample points to the
point sets, Q
max
and Q
min
, respectively. We then extract the
lines of maximum curvature with the following three
steps:
(a) All the points in Pare added to a priority queue and
are sorted by their confidence values. The points
with higher confidence are assigned with higher
priority.
(b) Pop a new seed point p
i
from the priority queue and
add it to Q
max
as s
0
. A tracing process is then started
from s
0
in two directions: T
max
and T
max
.
(c) For each new sample point s
k+1
, if none of the stop-
ping conditions is satisfied, it will be added to Q
max
,
and the local neighbors of s
k
are labeled and
removed from the priority queue. Otherwise, the
tracing process in the current direction will be
ended.
Steps (b) and (c) are repeated until all points are labeled
or the priority queue is empty. The lines of maximum cur-
vatures are then computed. The lines of minimum curva-
tures are computed in the same way. The density of the
curvature lines is controlled by step size
x
and local neigh-
borhood size d, where d> 0.5
j
,2d>
x
>d, and
j
is the
average station distance of the point set. Fig. 7 shows the
final results of the computed maximum and minimum cur-
vature lines, with different resolutions under various
parameters.
4. Construction of quad-dominant meshes
Our method involves the following two steps in con-
structing quad-dominant meshes from point clouds. First,
all intersection points between the maximum and mini-
mum line segments are computed and indexed. Second,
according to the final indexes, the quad-dominant meshes
over the point cloud are generated by the use of half-edge
structures. For simplicity, we refer to the line segments on
the lines of maximum curvature as ‘‘maximum line seg-
ments’’ and those on the lines of minimum curvature as
‘‘minimum line segments’’.
Fig. 6. The tracing process of curvature lines. The red point is the seed
point. The blue point is the current sample. The green point is the new
sample. As a new sample point is detected, the neighbors of the
previously sampled point will be labeled. (For interpretation of the
references to colour in this figure legend, the reader is referred to the web
version of this article.)
90 X. Pang et al. / Graphical Models 76 (2014) 86–102
4.1. Intersection of curvature lines
After obtaining the curvature lines, we need to deter-
mine their intersections as the input to the quad meshing
process. Instead of applying the time consuming parame-
terization or Voronoi space partitioning process, we con-
struct a specialized KD-tree structure over the points of
curvature lines. The problem of recovering the topological
structures of the intersection points can be converted to a
simple sorting problem.
In Section 3.2, a data structure S
j
={s
1
,...,s
k
,...,s
n
}is
used to maintain the points on each curvature line, where
jis the line index and kis the point index. Thus, each point
on the a curvature line can be indexed by jand k. The com-
puted intersection point is recorded as C
i
and added to a
vertex list Vas follows:
V¼fC
i
ðc
i
;n
i
;l
max
;p1
max
;p2
max
;d
max
;l
min
;p1
min
;p2
min
;
d
min
;l
0
max
;p
0
max
;l
0
min
;p
0
min
Þg;i¼0;...;M;
where Mis the number of intersection points. As shown in
Fig. 8,C
i
consists of the following elements: the intersec-
tion point c
i
, the normal n
i
, the line indexes of the inter-
sected curvature lines l
max
and l
min
, and the point indexes
of the end points on the intersected line segments p1
max
,
p2
max
,p1
min
and p2
min
. Since there may be redundant
intersection points, the distances between c
i
to p1
min
and
p1
max
are separately recorded as d
min
and d
max
, in order
to assist redundancy elimination. Finally, after filtering
the intersection points, for each remaining c
i
, the new line
index and point index referring to the maximum and min-
imum curvature lines can be obtained as ðl
0
max
;p
0
max
and
ðl
i
min
;p
0
min
Details for obtaining the intersection points are
elaborated in the following four steps.
4.1.1. Querying the neighboring line segments
A KD-tree is first constructed over the points of mini-
mum curvature lines by querying their line and point in-
dexes. For each maximum line segment L, its neighboring
points on the minimum curvature lines can be easily re-
trieved by searching a neighborhood centered at the mid-
dle point of Lon the KD-tree, as shown in Fig. 9. The
neighboring points with same line index and adjacent
point indexes are then connected as the neighboring line
segments. By sorting the neighboring points by their line
index followed by their point index, the neighboring line
segments or consecutive line segments can be easily ob-
tained by checking the line and point indexes of the adja-
cent points in the list.
Since the points with the same line index are sorted by
their point indexes, the first and second endpoints for each
neighboring segment can be easily defined. With this
scheme, the computational cost of searching for the neigh-
boring line segments can be reduced from m(m1)/2 to
m1, where mis the number of neighboring points.
4.1.2. Determining the intersection points
In our algorithm, the intersections of curvature lines are
directly computed in 3D space. Singular problem may oc-
cur if the curvature lines do not exactly intersect at one
point. To solve this problem, the common perpendicular
line of the two line segments are computed first. Their
intersection point is then defined as the middle point of
the common perpendicular line, as shown in Fig. 10a.
Let q1q2 and p1p2 be the maximum and minimum line
segments, respectively. Let also vq,vp be the two end
points of the computed common perpendicular line, such
that point vq and vp are the perpendicular foots on q1q2
and p1p2, respectively. We may determine if line segments
q1q2 and p1p2 intersect with each other as follows:
Fig. 7. Lines of maximum (blue) and minimum (red) curvatures are computed for the Venus point cloud. Curvature lines computed with (a): d= 1.2
j
and
x
= 1.2d, (b): d= 2.0
j
and
x
= 1.2d, and (c): d= 3.0
j
and
x
= 1.2d. (For interpretation of the references to colour in this figure legend, the reader is referred to
the web version of this article.)
Fig. 8. Intersection of maximum and minimum line segments. The black
line is perpendicular to both line segments, with the two black points
being the perpendicular foots on the line segments.
X. Pang et al. / Graphical Models 76 (2014) 86–102 91
ðq1
v
qÞðq2
v
qÞ<0 AND ðp1
v
pÞðp2
v
pÞ
<0ð8Þ
If Eq. (8) is satisfied, the intersection point of q1q2 and
p1p2 is then: c
i
=(vp +vq)0.5. n
i
is computed as the nor-
malized average of the surface normals of points q1, q2,
p1, and p2. Meanwhile, the corresponding parameters l
max
,
p1
max
,p2
max
,d
max
,l
min
,p1
min
,p2
min
,d
min
are also recorded
in C
i
. If Eq. (8) is not satisfied, there will be no intersection
points for q1q2 and p1p2.
For some special cases as shown in Fig. 10b and c, if a
point shared by two consecutive line segments is very
close to the other line segments, the intersection point
for these two sets of line segments may not be detected.
We propose the following new scheme to find the missing
intersection points:
(a) If one maximum line segment fails to intersect with
its neighboring minimum line segment, its neigh-
boring consecutive minimum line segments are
extracted. The new line segment that connects the
middle points of the two consecutive minimum line
segments are added as shown in Fig. 10b. Then the
intersection of the current maximum line segment
and the newly added line segment can be computed.
If there exist an intersection point, the point indexes
of the newly added line segment will be separately
computed as the average values of point indexes of
the two consecutive minimum line segments.
(b) If there are no intersection points for two consecu-
tive maximum line segments, a new line segment
is added to connect the middle points of these two
maximum line segments. The intersection of this
new line segment and its neighboring minimum line
segment is computed. If an intersection point exists,
the point indexes of the newly added line segment
are separately computed as the average values of
the point indexes of the two consecutive maximum
line segments. Otherwise, step (a) will be performed
on the added line segment to find the missing inter-
section point as shown in Fig. 10c.
The appendix details and evaluates the proposed algo-
rithm for computing intersection points.
4.1.3. Recovering the topology and filtering the intersection
points
The computation of intersection points is performed by
traveling along the lines of maximum curvatures. Thus the
order of intersection points recorded in Vis related to the
topology of the lines of maximum curvatures. To
recover the topology of lines of minimum curvatures for
Fig. 9. For each maximum line segment (blue), the neighboring points (red) on the minimum curvature lines are detected. Since points on the minimum
curvature lines are queried by the line and point indexes, neighboring minimum line segments can be extracted by sorting the newly generated neighboring
point indexes. (For interpretation of the references to colour in this figure legend, the reader is referred to the web version of this article.)
Fig. 10. Retrieval of the missing intersection points for special cases. (a) The intersection point (green) is set as the midpoint of the common perpendicular
line (black) between the two line segments (red and blue); (b) For a maximum line segment (blue), if there is no neighboring minimum line segment (red)
intersecting with it, a new line segment (black) is added to connect the middle points of the two consecutive minimum line segments. The intersection of
the maximum line segment (blue) and the new line segment (black) is then computed; (c) If two consecutive maximum line segments (blue) do not
intersect and their newly added line segment do not intersect with its neighboring minimum line segments, another new line segment can be added to the
neighboring two consecutive minimum line segments. The intersection of these two newly added line segments (black) is then computed. (For
interpretation of the references to colour in this figure legend, the reader is referred to the web version of this article.)
92 X. Pang et al. / Graphical Models 76 (2014) 86–102
intersection points, a new index list VX is constructed. For
each intersection point c
i
, a floating-point index is com-
puted as idx
min
=l
min
N+ 0.5 (p1
min
+p2
min
). The index
list VX can then be obtained by sorting all indexes, idx
min
,
in ascending order.
However, singular problems may occur when recover-
ing the topology of intersection points. For a single line
segment, it may have two intersection points with two
consecutive line segments as shown in Fig. 11a and b, or
two or more intersection points with the line segments
from different curvature lines as shown in Fig. 11c and d.
The first case may produce redundant intersection points.
For the second case, the intersection parameters p1
max
,
p2
max
or p1
min
,p2
min
of these adjacent intersection points
are the same, e.g., the adjacent points shown in Fig. 11c
have same p1
max
,p2
max
, and the adjacent points in
Fig. 11d have same p1
min
,p2
min
. This may cause incorrect
ordering of intersection points in Vand VX. The methods
to handle these special cases are depicted below:
(a) By traversing the intersection points in V, adjacent
intersection points that have the same line index l
min
or adjacent point-index values p1
min
,p2
min
are
removed from Vand replaced by their median point
as shown in Fig. 11a and b. For the adjacent points
with same indexes p1
max
,p2
max
and different line
index l
min
, e.g., Fig. 11c, they are re-sorted by d
max
in ascending order.
(b) The index list VX for intersection points is updated
by re-sorting newly generated indexes, idx
min
=
l
min
N+ 0.5 (p1
min
+p2
min
)+d
min
, in ascending
order.
(c) By traversing the updated VX, the adjacent points
with same point indexes p1
min
,p2
min
and different
line index l
max
, e.g., as shown in Fig. 11d, are re-
sorted by d
min
in ascending order.
4.1.4. Constructing the final indexes for the intersection points
With the above steps, the final line index l
0
max
and point
index p
0
max
for each intersection point is obtained by tra-
versing the filtered Vwhile referencing the topology of
lines of maximum curvatures. Likewise, the final line index
l
0
min
and point index p
0
min
for each intersection point is
obtained by traversing the updated VX while referencing
the topology of lines of minimum curvature. During the
traversal process, a flow line of maximum or minimum
curvature is finished if the next intersection point belongs
to a different flow line, i.e., the current value of l
max
or l
min
is different from that of the next intersection point. Once
the newly generated line index l
0
max
;l
0
min
and point index
p
0
max
;p
0
min
of each intersection point are recorded in V, adja-
cent intersection points can be determined efficiently.
Fig. 12 shows an example of computed intersection points
of curvature lines for a 3D model.
4.2. Quad-dominant meshing based on half-edge structure
For an intersection point with indexes
l
0
max
;p
0
max
;l
0
min
;p
0
min
as shown in Fig. 13a, we may find its
adjacent vertexes via V. With this adjacency information,
we may construct adjacent edges from each intersection
point to its adjacent vertexes. Then the edges are sorted
in a counter-clockwise direction and the half-edge struc-
tures around each intersection point can be constructed.
For each incoming half-edge, its next half-edge is an outgo-
ing half-edge on the next edge in the sorted array as shown
in Fig. 13b.
For each half-edge in the computed list, based on the
next-previous relation defined by the half-edge structure,
a mesh patch can be constructed by traversing all the next
half-edges until reaching the starting edge again. Mean-
while, the half-edges involved in this patch are labeled
and excluded in the remaining traversal. Sometimes, espe-
cially for the poorly sampled models, the constructed
patches may fill a big hole of the model. This problem
can be solved by adjusting the number of half-edges in-
volved in one patch. Some of quad-dominant meshing re-
sults are as shown in Fig. 14.
4.3. Analysis of approximation error
Since the curvature lines are generated on the fitting
surface domain, the accuracy of the computed quad-
dominant meshes is mainly determined by the accuracy
of the surface approximation process. According to the
analysis in [21], to approximate a bivariate function fby
Fig. 11. Ambiguous situations in computing intersection points. (a) Adjacent intersection points in Vwith the same line index l
min
and adjacent point-index
values p1
min
,p2
min
(labeled as p
min,
p
min
+1, p
min
+ 2); (b) Adjacent intersection points in Vwith the same line index l
min
and point indexes p1
min
,p2
min
(labeled as p
min
,p
min
+ 1); (c) Adjacent points in Vwith the same point indexes p1
max
,p2
max
(labeled as p
max
,p
max
+ 1) and different line index l
min
(labeled
as l
min
,l
min
+ ln); (d) Adjacent points in VX with the same point indexes p1
min
,p2
min
(labeled as p
min
,p
min
+ 1) and different line index l
max
(labeled as l
max
,
l
max
+ ln).
X. Pang et al. / Graphical Models 76 (2014) 86–102 93
a polynomial gof total degree m, the approximation error
can be expressed as jjgfjj 6Mh
mþ1
, where Minvolves
the (m+ 1)-th derivatives of f, i.e., M
e
O(||f
(m+1)
||).
In this work, the error of a local fitting surface can be
formulated as [14]:
error ¼X
p
j
2NBHDðp
i
Þ
ððp
j
p
i
Þn
i
g
i
ðu
j
;
v
j
ÞÞ
2
ð9Þ
where p
i
is the sample point, NBHD(p
i
) is the neighboring
points of p
i
, and g
i
is the fitting polynomial. Then, the upper
bound error of the approximation error can be deduced as:
jjS
P
[G
i
jj 6M
mþ1
h
mþ1
ð10Þ
where S
p
is a surface defined by the input points, and G
i
is
the polynomial patch defined by a fitting polynomial g
i
for
point p
i
.
5. Experimental results and discussion
In above sections, we have shown results of the pro-
posed meshing algorithm applied on various point cloud
models. In all the examples, only the 3D point coordinates
are used as input to the algorithm. In this section, we con-
duct more experiments to evaluate the performance of the
algorithm in terms of: computation time, memory cost,
robustness to extra noise, and multi-resolution meshing.
5.1. Computational efficiency and memory requirement
We run the proposed quad-dominant meshing algo-
rithm on a PC with an AMD Athlon 2.7 GHz CPU and 2 GB
RAM. (All experiments were based on a single core imple-
mentation.) Table 1 shows the computation time of each
stage, the overall computation time and the maximum
amount of memory usage of our algorithm for different
models. The parameters are set as d= 0.8
j
and
x
= 1.2d.
The results show that our algorithm can handle about
1–2 K points per second. It is much faster than Kalogerakis
Fig. 12. The computed flow line intersection points for a 3D point cloud
model of bunny.
Fig. 13. (a) For a given intersection point, its adjacent points can be obtained from Vand VX; (b) The half-edge structures for each vertex.
Fig. 14. Quad-dominant meshing results on the 3D point cloud models of: (a) Dragon, and (b) Venus, with the parameter setting of d= 0.8
j
and
x
= 1.2d.
94 X. Pang et al. / Graphical Models 76 (2014) 86–102
et al.’s algorithm [10], which was executed on a PC with an
Intel P4 3 GHz single-core CPU and 2 GB RAM and reported
to handle 139–222 points per second.
In addition, since their algorithm uses a denoising pro-
cess and ours do not, we have also compared the computa-
tion times for flow line tracing and mesh generating here.
Kalogerakis et al.’s algorithm reports a speed of 230–420
points per second, and our method can handle about
1–4.5 K points per second. The main difference between
our algorithm and their algorithm is that they calculate
the curvature lines and line intersections based on Voronoi
space partitioning, while ours is based on a fast marching
scheme and the efficient KD-tree structure. As a result,
our algorithm is more efficient.
5.2. Robustness to extra noise
We validate the robustness of the proposed algorithm
on point clouds with added Gaussian noise. Fig. 15a and b
shows the noisy Deself model generated by adding stan-
dard Gaussian noise of standard deviation
r
= 0.2
j
to
the original Deself model shown in Fig. 2.Fig. 15c and d
demonstrate the robustness of the proposed algorithm
to noise.
5.3. Multi-resolution meshing
Density of the mesh is determined by the density of the
curvature lines, which can be controlled by the step size
x
and local neighbor size d, as discussed in Section 3.2.
Hence, multi-resolution quad-dominant meshes can be
obtained by setting different parameter values, as shown
in Fig. 16. The computation times for generating multi-
resolution representations are given in Table 2. The
computation time is lower at low resolution settings.
5.4. Discussion on meshing quality and limitations
Since the principal directions are not well defined in the
areas with low confidence, the flow lines in these areas
usually fail to intersect with each other. In our algorithm,
by propagating the principal directions from regions with
high confidence to regions of low confidence, the proposed
curvature tensor optimization method can reduce the
number of points in the point cloud with low confidence.
Thus singular meshes (concave and convex faces) caused
by missing flow lines intersections can be reduced as
shown in Figs. 4 and 17.
For regions with valley-ridge or sharp features, the pro-
posed algorithm usually assigns high confidence, and high
priority in the curvature line tracing process. As shown in
Fig. 18, where the curvature lines are colored according
to the values of the principal curvatures, the computed
flow lines can match well with the features. Thus, valley-
ridge features, such as the bunny ears in Fig. 18a and the
dragon model in Fig. 18b, and sharp features in Fig. 18c
can be preferentially preserved in the final quad-dominant
meshes. In addition, sharp features, such as the horse ears
in Fig. 16g–i, are also well preserved at either high or low
resolution.
Table 1
Evaluation of computation time (in seconds) and memory cost (in MB). (
j
is the average station distance.) (a) normal correction; (b) curvature tensor
calculation; (c) extraction of flow lines; (d) intersection and meshing.
Dataset # Of points/# of mesh
j
Running times (s) Maximal memory
(a) (b) (c) (d) Total
Hand-H 23.8 K/10.0 K 0.008 2.6 2.7 4.2 2.2 11.9 48
Hand-L 6.61 K/2.7 K 0.015 0.3 0.5 1.2 0.2 2.4 34
Bunny 35.9 K/14.1 K 0.0174 1.9 3.9 12.3 5.1 23.4 54
Fran-rgb 34.0 K/13.9 K 0.0138 1.5 4.8 6.5 4.6 17.6 58
Horse 48.5 K/9.8 K 0.0055 1.8 7.0 11.8 10.4 31.2 55
Dself 14.8 K/4.9 K 0.0170 0.7 3.3 3.0 0.7 7.8 39
Dinosaur 69.3 K/24.1 K 0.0066 3.9 12.9 19.3 19.8 56.0 84
Venus 134.4 K/55.0 K 0.0090 16.2 18.5 29.3 137.2 201.3 147
Squirrel 76.8 K/31.8 K 0.0107 4.8 10.1 14.7 29.8 59.6 93
Fig. 15. Quad-dominant meshing on the Dself model with added Gaussian noise of
r
= 0.2
j
. (a) the noisy Dself model. (b) magnified front view (upper
figure) and side view (lower figure) of the selected region in the noisy model. (c) magnified front view (upper figure) and side view (lower figure) of the
selected region in the quad-meshes. (d) The quad-meshes are well constructed from the noisy model.
X. Pang et al. / Graphical Models 76 (2014) 86–102 95
Concave and convex faces are undesirable in the ren-
dering and modeling processes [5]. Such faces usually ap-
pear in the umbilical regions, where the principal
directions are not well defined, i.e., the regions with low
confidence. This is a common problem for quad-dominant
meshing methods [4,5]. It also affects our method since the
integration operator for curvature lines are usually termi-
nated in these regions. A common way to eliminate these
singular polygons is to add conforming edges so as to di-
vide them into some finer patches as shown in Fig. 19.
The key point for partitioning these faces is to extract the
T-vertices, concave and convex faces. This can be easily
realized in our method by checking the number of adjacent
points for each intersection point while building the half-
edge structures. For example, a point with two adjacent
points can be defined as a point on a concave face, and a
Fig. 16. Multi-resolution quad-dominant meshing results on different models. (a–c) Hand-H, (d–f) Dself, and (g–i) Horse, at different parameter values of d
and
x
.
Table 2
Computation times (in seconds) of multi-resolution quad-dominant
meshing.
Dataset Parameters d/
x
# of mesh Total time
Hand-H 1.0
j
/1.2d36.5 K 9.801
1.2
j
/1.2d28.8 K 8.547
1.5
j
/1.2d20.7 K 7.492
Dself 1.0
j
/1.2d19.8 K 6.953
1.2
j
/1.2d15.7 K 6.017
1.5
j
/1.2d11.7 K 5.531
Horse 1.0
j
/1.2d73.3 K 21.82
1.2
j
/1.2d59.3 K 16.70
1.5
j
/1.2d42.9 K 13.89
96 X. Pang et al. / Graphical Models 76 (2014) 86–102
point with three adjacent points can be defined as a
T-vertex. By traversing the half-edge structures, convex
or concave faces with more than four edges can be detected.
For the models tested in Table 1, the numbers of con-
vex/concave faces and T-vertices are given in Table 3.As
we can see, the number of convex and concave faces is rel-
atively small, and the number of the T-vertices is relatively
high. This is because the boundary points, which usually
exist as T-vertices, are also counted in our evaluation. This
means that the meshing quality can be further improved if
the concave and convex faces can be well treated in the fu-
ture work.
Unlike traditional point cloud meshing techniques that
use parameterization or Voronoi space partitioning, the
proposed method does not require to have the whole
topological structure of the point cloud. The curvature
lines are obtained using the local topology predicted by
local surface fitting. Thus, as shown in Fig. 20, for point
clouds with ambiguous topologies, singular meshes may
be produced and ambiguity eliminations are needed to
correct the ambiguous topology of the generated quad
meshes. In addition, the proposed method may have dif-
ficulties in handling point clouds with very low density.
This is because of two reasons. First, the errors of normal
estimation and surface approximation are higher for low
resolution point clouds [21]. Second, the step size
x
used
in the tracing process should be larger than the average
station distance
j
, since the marching scheme is used to
control the flow line density. As shown in Fig. 21, some
tiny features like the tiger tail are not meshed well. Fur-
ther improvement to the stopping conditions in Sec-
tion 3.2 is desirable in order to produce better quad
meshes for low resolution point clouds. Note that our
quad mesh construction process relies on determining
intersections of two distinct types of curvature lines. As
our method does not perform swapping between maxi-
mum and minimum curvature lines, quad meshes may
not be well constructed in umbilical regions, where prin-
cipal directions are not well defined and some flow lines
may intersect themselves.
6. Conclusion and future work
This article presents a novel method for the construc-
tion of quad-dominant meshes from unorganized raw
point cloud data. Marinov’s curvature tensor optimization
process is first applied to the point cloud to achieve a
smooth curvature tensor with fewer umbilical regions. A
fast marching scheme is then applied to extract the curva-
ture lines with controllable density. To find the intersec-
tion points of the curvature lines, all the intersection
points between the maximum and minimum line seg-
ments are computed and indexed according to the topol-
ogy of maximum and minimum curvature lines. Finally,
according to the final indexes of the intersection points,
Fig. 17. Quad-dominant meshing results on the hand models. (a) Quad-dominant meshes on Hand-L computed from originally computed curvature tensor;
(b) Quad-dominant meshes on Hand-L computed from the optimized curvature tensor; (c) Quad-dominant meshes on Hand-H computed from the original
curvature tensor; (d) Magnification of the selected areas; (e) Quad-dominant meshes on Hand-H computed from the optimized curvature tensor.
X. Pang et al. / Graphical Models 76 (2014) 86–102 97
the quad-dominant meshes over the point cloud can be
generated by the use of half-edge structures. Compared
with traditional point cloud meshing techniques, the time
consuming parameterization or Voronoi space partitioning
process is avoided. As a result, the computation time can
be significantly reduced. We have tested the proposed
method on a variety of point cloud models, and the results
show that the proposed method can produce acceptable
multi-resolution meshes with high efficiency and low
memory usage.
Fig. 18. Features and valley-ridges are well preserved in the generated quad-dominant meshes. (a) Sharp features in the bunny ears; (b) Valley-ridge
features on the dragon model; (c) Sharp features on ice-cube. The right diagrams show the colored principal curvatures of vertices on quad meshes.
Fig. 19. A hybrid quad or triangle mesh is generated by adding
conforming edges (red) to the T-junctions in a systematic manner [4].
(For interpretation of the references to colour in this figure legend, the
reader is referred to the web version of this article.)
Table 3
Quality evaluation from statistical information: the number of points on lines of maximum and minimum curvatures, and the numbers of convex/concave faces
and T-vertices on various models.
Dataset # Of points on maximum and minimum curvature lines # Of mesh # Of convex /concave faces # Of T-vertices
Hand-H 18.74 K/19.61 K 10.06 K 0.29 K/0.25 K 0.75 K
Hand-L 5.30 K/5.62 K 2.71 K 0.14 K/0.07 K 0.27 K
Bunny 29.19 K/29.82 K 14.17 K 0.59 K/0.60 K 1.50 K
Fran-rgb 27.17 K/27.66 K 13.90 K 0.51 K/0.39 K 1.27 K
Horse 14.43 K/13.62 K 9.89 K 0.14 K/0.21 K 1.73 K
Dself 12.15/12.07 K 4.97 K 0.44 K/0.26 K 0.57 K
Dinosaur 58.91 K/60.11 K 24.19 K 1.58 K/1.43 K 3.24 K
Venus 108.34 K/109.07 K 55.05 K 1.54 K/2.06 K 4.92 K
Squirrel 61.02 K/61.68 K 31.86 K 0.81 K/0.72 K 2.72 K
98 X. Pang et al. / Graphical Models 76 (2014) 86–102
In our experiments, we have found that polynomials of
degree 2 are effective for surface fitting in most of our
point cloud models. However, we have also noticed that
the fitting quality of the quadrilateral meshes can be sig-
nificantly improved by using different fitting models for
different kinds of surfaces, such as a plane or a conical sur-
face. A possible future work is to develop a technique to
automatically determine an appropriate surface fitting
model with no given priors. Another interesting future
work is to investigate how to improve the meshing quality
of the umbilical regions by extracting the topological skel-
etons of the curvature tensor.
Acknowledgments
This work was supported in part by the National Natu-
ral Science Foundation of China (NSFC Grant Nos.:
61002040, 60903115), the Introduced Innovative R&D
Team of Guangdong Province-Robot and Intelligent Infor-
mation Technology (Grant No.: 201001D0104648280),
the Shenzhen Key Lab for Computer Vision and Pattern
Recognition (Grant No.: CXB201104220032A), and a GRF
grant from the Research Grants Council of Hong Kong
(RGC Reference No.: CityU 115112).
Appendix A.
In the proposed method, the computation of intersec-
tion points is affected by several factors, such as the length
of the line segments, the distance between line segments
and intersection angles. We evaluate its performance by
estimating the ratio of missing intersection points as
follows.
Given a line segment q1q2 and a spatial point p1 not
belonging to q1q2, the calculation of intersection points
and the estimation of missing ratio are depicted in
Fig. 22 and in following three steps. (In the following dis-
cussion, p2, p3 and p4 represent any effective points, which
are located on a part or half sphere colored in grey or pink,
connected to p1, p2 and p3, respectively.)
A.1. Step 1: Estimating intersection between q1q2 and p1p2
i
In our experiments, the distance between p1 and q1q2
is set to d= 1.0, and the plane defined by p1, q1, q2 is de-
noted as PL0. To simplify the computation, we uniformly
sample p2 with step size of 1-degree on a unit sphere
SP1(p1, r1 = 1.0), where p1 is the center and r1 is the ra-
dius. Since the line segments of maximum and minimum
curvatures are separately generated by tracing the princi-
pal directions, for points on SP1, only the points on the
right side of the plane PL1 are considered, where PL1 is per-
pendicular to plane PL0 and contains point p1. As shown in
Fig. 22a, the effective points are colored in grey and de-
noted as P2{p2
i
,i=0,...,n}. By computing the common
perpendicular line of q1q2 and line segment p1p2
i
, the per-
pendicular foot on p1p2
i
can be obtained and denoted as
Vp12
i
. To check if there is an intersection point on p1p2
i
,
we define a parameter
D
i
as:
D
i
¼ðp1Vp12
i
Þðp2
i
Vp12
i
Þ
If
D
i
< 0, it means that Vp12
i
lies on line segment p1p2
i
and
can be considered as an intersection point. Otherwise,
Vp12
i
is not an intersection point and p2
i
will be added
to the point set P2
0
¼p2
0
i
0
,i
0
=0,...,n
0
}. As shown in
Fig. 23a and b, each p2
i
in P2 is colored according to the va-
lue of
D
i
, and P2
0
can be obtained. Thus, the missing ratio of
intersection points in the 1st step can be estimated as
x
1=n
0
/n.
A.2. Step 2: Computing intersection between p2
0
i
0
p3
i
0
j
and q1q2
In Step 1, for each p2
0
i
0
,p3 is uniformly sampled on a
unit sphere SP2
i
0
(p2
i
0
,r2 = 1.0) to construct line segment
p2
0
i
0
p3. Points on the curvature line segments are sampled
from locally fitted manifold surfaces. Thus if the curvature
Fig. 20. Singular meshes caused by the ambiguous topologies of the point cloud.
Fig. 21. Ambiguous and incorrect topology may exist in a quad-dominant mesh generated from a low-resolution point cloud.
X. Pang et al. / Graphical Models 76 (2014) 86–102 99
lines are meaningfully ‘‘crossed’’, p1 and p3 should lay on
opposite sides of plane PL2, which is perpendicular to PL0
and passes through q1q2. As shown in Fig. 22b, only the
points on the right side of PL2 are considered and denoted
as P3
i
0
¼P3
i
0
j
,j=0,...,m}. By computing the common per-
pendicular line of q1q2 and line segment p2
0
i
0
P3
i
0
j
, the
perpendicular foot Vp23
i
0
j
on line p2
0
i
0
p3
i
0
j
can be obtained.
Fig. 24b shows the point set of P3
i
0
based on the value:
D
i
0
j
¼ðp2
0
i
0
Vp23
i
0
jÞðp3
i
0
j
Vp23
i
0
j
Þ.If
D
i
0
j
>0, there is
no intersection point on line segment p2
0
i
0
p3
i
0
j
and p3
i
0
j
will
be added to a point set: P3
0
i
0
¼fp3
0
i
0
j
0
;j
0
¼0;...;m
0
g. Thus,
the ratio of missing intersection points for p2
0
i
0
in this step
Fig. 22. (a) Calculation of the intersection point between q1q2 and p1p2, where p2 is sampled from SP1(p1, r1); (b) Calculation of the intersection between
p2
0
i
0
p3
i
0
j
and q1q2, where p2
0
i
0
is a point fails to intersect with q1q2 in the 1st step, and p3
i
0
j
is sampled from SP2
i
0
ðp2
i
0
;r2Þ; (c) Calculation of the intersection
between m1
i
0
m2
i
0
j
0
and q1q2, where m1
i
0
and m2
i
0
j
0
are the middle points of p1p2
0
i
0
and p2
0
i
0
p3
i
0
j
0
:.
Fig. 23. Estimation of the intersections of q1q2 with any line segments p1p2
i
. (a) Each point in P2 is colored according to the value of
D
i
; (b) The visual result
of point set P2
0
. (For interpretation of the references to colour in this figure legend, the reader is referred to the web version of this article.)
Fig. 24. Estimation of the intersection between p2
i
0
p3
i
0
j
and q1q2. (a) Each
point p2
0
i
0
in P2
0
is colored according to x2
i
0
; (b) p3
0
i
0
j
0
is colored according
to the value of
D
i
0
j
; (c) The visual intersection result for line segments
starting from point p2
0
i
0
:. (For interpretation of the references to colour in
this figure legend, the reader is referred to the web version of this article.)
Fig. 25. Estimation of the intersection between m1
i
0
m2
i
0
j
0
and q1q2. (a)
Each point p2
0
i
0
in P2
0
is colored according to x2
0
i
0
; (b) The final
intersection result for line segments that start at point p2
0
i
0
:. (For
interpretation of the references to colour in this figure legend, the reader
is referred to the web version of this article.)
100 X. Pang et al. / Graphical Models 76 (2014) 86–102
can be computed as
x
2
i
0
¼m
0
=m.Fig. 24a shows a visual
computation of each point p2
0
i
0
with respect to
x
2
i
0
.
A.3. Step 3: Computing intersection between m1
i
0
m2
i
0
j
0
and
q1q2
For any line segment p2
0
i
0
p3
0
i
0
j
0
that fails to intersect with
q1q2 in the 2nd step, the intersection points can be calcu-
lated from line segments m1
i
0
m2
i
0
j
0
and q1q2, where m1
i
0
and m2
i
0
j
0
are the middle points of lines p1p2
0
i
0
and
p2
0
i
0
p3
0
i
0
j
0
. By computing the common perpendicular line of
q1q2 and m1
i
0
m2
i
0
j
0
, the perpendicular foot on line
m1
i
0
m2
i
0
j
0
can be obtained and denoted as Vm
i
0
j0
. According
to the value of
D
i
0
j
0
¼ðm1
0
i
0
Vm
i
0
j0
Þðm2
i
0
j
0
Vm
i
0
j
0
Þ,if
D
i
0
j
0
>0, p3
0
i
0
j
0
will be added to another point set:
P3
00
i
0
¼fp3
00
i
0
k
;k¼0;...;m
00
g. The final missing ratio of inter-
section points of all line segments that start at p2
0
i
0
can then
be computed as
x
2
0
i
0
¼m
00
=m.Fig. 25a shows a visual result
according to the value of
x
2
0
i
0
.
Suppose event A denoting that p1p2
i
has no intersection
with q1q2, and event B denoting that both p2
0
i
0
p3
i
0
j
and
m1
i
0
m2
i
0
j
0
have no intersection with q1q2. The ratio of
Fig. 26. The relationship between
g
and parameters {d,r1, r2}. (a) {d,r1, r2} vary from 0.1 to 1.8 with a step size of 0.1, the ratio of missing intersection
points for line segments generated from one group of {d,r1, r2} is illustrated by coloring the point (d,r1, r2) according to
g
; (b) Tetrahedral meshing of the
points are performed to give a more clear view; (c–f): Relationship between
g
and parameters {d,r1, r2} from different viewpoints. (For interpretation of the
references to colour in this figure legend, the reader is referred to the web version of this article.)
Fig. 27. (a) The relationships between
g
and d,r1, r2, where r1r2; (b) If p2p3 fails to intersect with q1q2, there is a great chance that p2p3, p3p4 intersect
with q1q2.
X. Pang et al. / Graphical Models 76 (2014) 86–102 101
missing intersections,
g
, for line segments p1p2, p2p3 can
be computed as P(AB).
Suppose that {C0, C1, ...,Ci
0
,...,Cn
0
}, i
0
=0,...,n
0
are
mutually exclusive events, where Ci
0
denotes the picking
of any p2
0
i
0
from P2
0
. In our case, P(Ci
0
) = 1.0/n
0
. According
to the law of total probability,
g
can be calculated as:
PðBÞ¼X
i
0
¼n
0
i
0
¼0
PðCi
0
ÞPðB=Ci
0
Þ¼X
i
0
¼n
0
i
0
¼0
ð1:0=n
0
Þ
x
2
0
i
0
g
¼PðABÞ¼
x
1X
i
0
¼n
0
i
0
¼0
ð1:0=n
0
Þ
x
2
0
i
0
In our experiments, while d= 1.0 (the distance between p1
and line q1q2), r1 = 1.0 (radius of the sphere centered at
p1), and r2 = 1.0 (radius of the sphere centered at p2
0
i
0
),
g
for line segments starting from p1 is 0.00131129. In the
proposed algorithm, q1q2 is replaced by two consecutive
line segments, and the ratio of missing intersections can
then be computed as:
c
¼1ð1PðABÞÞ
2
To illustrate the relationships between parameters
{d,r1, r2} and the ratio of missing intersection points,
experiments under different parameters are performed.
Parameters d,r1 and r2 vary from 0.1 to 1.8 with a step size
of 0.1. However, parameter values of (r1+r2) < dare ig-
nored. As shown in Fig. 26, the ratio of missing intersection
points for line segments generated from one group of
{d,r1, r2} can be illustrated by coloring the point
(d,r1, r2) according to
g
.
The experiments show that, with decreasing
(r1+r2) d(i.e., the distance between p3 and q1q2), the
ratio of missing intersection points increases. However, in
our algorithm, the step size used in the tracing process of
curvature lines is equally or slowly changing with the cur-
vatures, and r1 can be assumed to be equal to r2. Thus, the
relationships between
g
and {d,r1, r2} can be depicted by
Fig. 27a. While r1r2d, i.e., p2 is near to q1q2. The va-
lue of
g
remains around 0.00131129. If p3 is near to q1q2,
according to the conclusions in Steps 2–3, there is a great
chance that p3p4 intersects with q1q2 as shown in Fig. 27b.
In addition, as shown in Fig. 25,P3
00
i
0
is close to q1q2 and
the intersection angle between q1q2 and p2
0
i
0
p3
Prime
i
0
k
is usu-
ally very small. Line segments like p2
0
i
0
p3
00
i
0
k
will not exist in
the tracing process, since the curvature lines are usually
orthogonally placed. Thus the real ratio of missing inter-
section points of the algorithm is far below the theoretical
results.
References
[1] E. Dazevedo, Are bilinear quadrilaterals better than linear triangles?,
SIAM J Sci. Comput. 22 (1) (2000) 198–217.
[2] R. Simpson, Anisotropic mesh transformations and optimal error
control, Appl. Num. Math 14 (1–3) (1994) 183–198.
[3] D. Bommes, B. Lévy, N. Pietroni, E. Puppo, C. Silva, M. Tarini, D. Zorin,
State of the art in quad meshing, Eurographics STAR Report, 2012.
[4] P. Alliez, D. Cohen-Steiner, O. Devillers, B. Lëvy, M. Desbrun,
Anisotropic polygonal remeshing, ACM Trans. Graphics 22 (3)
(2003) 485–493.
[5] M. Marinov, L. Kobbelt, Direct anisotropic quad-dominant
remeshing, Proc. Pacific Graphics 12 (2004) 207–216.
[6] N. Ray, W. Li, B. Lévy, A. Sheffer, P. Alliez, Periodic global
parameterization, ACM Trans. Graphics 25 (4) (2006) 1460–1485.
[7] F. Kälberer, M. Nieser, K. Polthier, Quadcover-surface
parameterization using branched coverings, Computer Graphics
Forum 26 (3) (2007) 375–384.
[8] D. Bommes, H. Zimmer, L. Kobbelt, Mixed-integer quadrangulation,
ACM Trans. Graphics 28 (3) (2009) 1–10.
[9] N. Pietroni, M. Tarini, O. Sorkine, D. Zorin, Global parametrization of
range image sets, ACM Trans. Graphics, 30(6) (2011).
[10] E. Kalogerakis, D. Nowrouzezahrai, P. Simari, K. Singh, Extracting
lines of curvature from noisy point clouds, Computer – Aid. Des. 41
(4) (2009) 280–292.
[11] E. Li, W. Che, X. Zhang, Y. Zhang, B. Xu, Direct quad-dominant
meshing of point cloud via global parameterization, Comput.
Graphics 35 (3) (2011) 452–460.
[12] M. Alexa, J. Behr, D. Cohen-or, S. Fleishman, D. Levin, C. Silva, Point
set surfaces, Proc. IEEE Visualization 537 (2001) 21–28.
[13] I. Daniels, K. Hal, T. Ochotta, C. Silva, Robust smooth feature
extraction from point clouds, Proc. IEEE Int. Conf. Shape Model.
Appl. (2007) 123–133.
[14] M. Alexa, J. Behr, D. Cohen-Or, S. Fleishman, D. Levin, C. Silva,
Computing and rendering point set surfaces, IEEE Trans.
Visualization and Computer Graphics 9(1) (2003) 3–15.
[15] T. Dey, G. Li, J. Sun, Normal estimation for point clouds: a
comparison study for a voronoi based method, Proc. Eurographics
(2005) 39–46.
[16] H. Hoppe, T. Derose, T. Duchamp, J. Mcdonald, W. Stuetzle, Surface
reconstruction from unorganized points, Proc. Computer Graphics
26 (1) (1992) 71–78.
[17] T. Delmarcelle, L. Hesselink, The topology of symmetric, second-
order tensor fields, Proc. Visualization 3 (1) (1994) 140–147.
[18] L. Hesselink, Y. Levy, Y. Lavin, The topology of symmetric, second-
order 3D tensor fields, IEEE Trans. Visualization Comput. Graphics 3
(1997) 1–11.
[19] V. Verma, D. Kao, A. Pang, A flow-guided streamline seeding strategy,
IEEE Visualization (2000) 163–170.
[20] X. Gu, S.-T. Yau, Global conformal surface parameterization, Proc. EG
Sympos. Geometry Process. (2003) 127–137.
[21] D. Levin, The approximation power of moving least-squares, Math.
Comput. 67 (1998) 1517–1531.
102 X. Pang et al. / Graphical Models 76 (2014) 86–102
ResearchGate has not been able to resolve any citations for this publication.
Article
Full-text available
We solve the problem of computing global conformal parameterizations for surfaces with nontrivial topologies. The parameterization is global in the sense that it preserves the conformality everywhere except for a few points, and has no boundary of discontinuity. We analyze the structure of the space of all global conformal parameteri-zations of a given surface and find all possible solutions by constructing a basis of the underlying linear solution space. This space has a natural structure solely determined by the surface geometry, so our computing result is independent of connectivity, insensitive to resolution, and independent of the algorithms to discover it. Our algo-rithm is based on the properties of gradient fields of conformal maps, which are closedness, harmonity, conjugacy, duality and symmetry. These properties can be formulated by sparse linear systems, so the method is easy to im-plement and the entire process is automatic. We also introduce a novel topological modification method to improve the uniformity of the parameterization. Based on the global conformal parameterization of a surface, we can con-struct a conformal atlas and use it to build conformal geometry images which have very accurate reconstructed normals.
Conference Paper
Full-text available
Many applications that process a point cloud data benefit from a reliable normal estimation step. Given a point cloud presumably sampled from an unknown surface, the problem is to estimate the normals of the surface at the data points. Two approaches, one based on numerical optimizations and another based on Voronoi diagrams are known for the problem. Variations of numerical approaches work well even when point clouds are contaminated with noise. Recently a variation of the Voronoi based method is proposed for noisy point clouds. The centrality of the normal estimation step in point cloud processing begs a thorough study of the two approaches so that one knows which approach is appropriate for what circumstances. This paper presents such results.
Conference Paper
Full-text available
We advocate the use of point sets to represent shapes. We provide a definition of a smooth manifold surface from a set of points close to the original surface. The definition is based on local maps from differential geometry, which are approximated by the method of moving least squares (MLS). We present tools to increase or decrease the density of the points, thus, allowing an adjustment of the spacing among the points to control the fidelity of the representation.To display the point set surface, we introduce a novel point rendering technique. The idea is to evaluate the local maps according to the image resolution. This results in high quality shading effects and smooth silhouettes at interactive frame rates.
Article
Recently, research originating in several different applications has appeared on unstructured triangular meshes in which the vertex distribution is not locally uniform, i.e. anisotropic unstructured meshes. The techniques used have the common features that the distribution of triangle shapes for the mesh is controlled by specifying a symmetric tensor, and that the anisotropic mesh is the transform of an isotropic mesh. We discuss how these mechanisms arise in the theory of optimal error control, using simple model mesh generation problems, and review the related research in applications to computational fluid dynamics, surface triangulation, and semiconductor simulation.
Conference Paper
Defining sharp features in a given 3D model facilitates a better understanding of the surface and aids visualizations, reverse engineering, filtering, simplification, non-photo realism, reconstruction and other geometric processing applications. We present a robust method that identifies sharp features in a point cloud by returning a set of smooth curves aligned along the edges. Our feature extraction is a multi-step refinement method that leverages the concept of robust moving least squares to locally fit surfaces to potential features. Using Newton's method, we project points to the intersections of multiple surfaces then grow polylines through the projected cloud. After resolving gaps, connecting corners, and relaxing the results, the algorithm returns a set of complete and smooth curves that define the features. We demonstrate the benefits of our method with two applications: surface meshing and point-based geometry compression.
Conference Paper
We describe and demonstrate an algorithm that takes as input an unorganized set of points {X1,...,nRTBC ⊂ IR3 on or near an unknown manifold M, and produces as output a simplicial surface that approximates M. Neither the topology, the presence of boundaries, nor the geometry of M are assumed to be known in advance - all are inferred automatically from the data. This problem naturally arises in a variety of practical situations such as range scanning an object from multiple view points, recovery of biological shapes from two-dimensional slices, and interactive surface sketching.
Article
We present a robust framework for extracting lines of curvature from point clouds. First, we show a novel approach to denoising the input point cloud using robust statistical estimates of surface normal and curvature which automatically rejects outliers and corrects points by energy minimization. Then the lines of curvature are constructed on the point cloud with controllable density. Our approach is applicable to surfaces of arbitrary genus, with or without boundaries, and is statistically robust to noise and outliers while preserving sharp surface features. We show our approach to be effective over a range of synthetic and real-world input datasets with varying amounts of noise and outliers. The extraction of curvature information can benefit many applications in CAD, computer vision and graphics for point cloud shape analysis, recognition and segmentation. Here, we show the possibility of using the lines of curvature for feature-preserving mesh construction directly from noisy point clouds.
Article
Abstract We introduce an algorithm for the automatic computation of global parameterizations on arbitrary simplicial 2-manifolds, whose parameter lines are guided by a given frame field, for example, by principal curvature frames. The parameter lines are globally continuous and allow a remeshing of the surface into quadrilaterals. The algorithm converts a given frame field into a single vector field on a branched covering of the 2-manifold and generates an integrable vector field by a Hodge decomposition on the covering space. Except for an optional smoothing and alignment of the initial frame field, the algorithm is fully automatic and generates high quality quadrilateral meshes.
Article
In this paper, we present a new algorithm for quad-dominant meshing of unorganized point clouds based on periodic global parameterization. Our meshing method is guided by principal directions so as to preserve the intrinsic geometric properties. We use local Delaunay triangulation to smooth the initial principal directions and adapt the global parameterization to point clouds. By optimizing the fairness measure we can find the two scalar functions whose gradients best align with the guided principal directions. To handle the redundant vertices in the iso-lines due to overlapped triangles, an approach is specially designed to clean the iso-lines. Our approach is fully automatic and applicable to a surface of arbitrary genus. We also show an application of our method in curve skeleton extraction from incomplete point cloud data.