View
218
Download
0
Category
Preview:
Citation preview
8/14/2019 Liu Mesh Editing
http://slidepdf.com/reader/full/liu-mesh-editing 1/8
Multi-Scale Method for Adaptive Mesh Editing Based on Rigidity Estimation
Jiongxin Liu† and Guangda Su‡
Department of Electronic Engineering
Tsinghua University
Beijing, China†liujiongxin@gmail.com, ‡susu@tsinghua.edu.cn
Abstract
We present a multi-scale approach for direct manip-
ulation of mesh models based on pre-estimated rigidity.Our method enhances space deformation by constructing a
novel deformable structure with several layers of deforma-
tion graphs which have different densities of control nodes.
An appropriate deformation graph is dynamically chosen
according to the handle configuration. Such handle-aware
strategy, together with special treatment for graph nodes,
brings great improvement on both editing effect and per-
formance. We demonstrate how to obtain a reduced de-
formable model by generating lattice structure and how to
estimate the rigidity of mesh surface. Based on the rigid-
ity analysis, we adjust the granularity of the computation
which helps to speed the solving process. The experimen-
tal results show that our method preserves detailed featureswell and provides fast design of pleasing poses as the com-
plexity of computing is confined within a limited range.
1. Introduction
Recent years have seen the progress of detail-preserving
mesh editing throughintuitive user interfaces. By constrain-
ing mesh vertices with handles, sophisticated deformation
algorithms respond to the user’s operation in a fast and nat-
ural way, producing visually pleasing result of the deformed
mesh. Generally, the deformation is formulated as an opti-
mization problem represented by a set of control variables.The challenge to solve such problem lies in its nonlinear-
ity and the computing complexity for large meshes with
50K + vertices. Many techniques build a coarse control
graph or subspace structure to define deformation of the
original mesh; however, how to construct an efficient re-
duced model still needs further investigation.
In handle-based interactive editing, the user selects a col-
lection of model vertices as handles to manipulate deforma-
tion directly. Usually, when one moveable handle is un-
Figure 1. Deformation examples generated byour system. The models can be deformed totake various poses in a matter of seconds.
der control, the other handles are guaranteed to be fixed in
place. Once all the handles are specified, the underlying de-formation propagation is determined in the sense that mesh
regions near the moveable handle are deformed more sig-
nificantly than those farther away, and the fixed regions are
not deformed at all. The extent of local deformation im-
plies rigidity which has been exploited to construct isolines
in [1]. Similarly, we use the knowledge of rigidity to choose
an appropriate editing scale. In this way, our system adapts
to the editing task intelligently, respecting the potential de-
formation and geometry.
Our rigidity-based approach couples with space defor-
mation defined by a collection of affine transformations and
it proceeds in two main steps. Firstly, once handle config-
uration is specified or changed, a position-based dynamicssimulation is performed to deform the shape lattice to con-
form with the handles. In the process, mesh surfaces as well
as control nodes are identified as being more or less rigidly
deformed and the system will have an idea of the upcom-
ing editing from the user. Secondly, an appropriate scale of
deformation graph is selected to run the optimization pro-
cedure. Deformation examples generated by our system are
shown in Figure 1.
Our primary contribution is the idea of automatically
Sixth Indian Conference on Computer Vision, Graphics & Image Processing
978-0-7695-3476-3/08 $25.00 © 2008 IEEE
DOI 10.1109/ICVGIP.2008.22
55
Sixth Indian Conference on Computer Vision, Graphics & Image Processing
978-0-7695-3476-3/08 $25.00 © 2008 IEEE
DOI 10.1109/ICVGIP.2008.22
55
Sixth Indian Conference on Computer Vision, Graphics & Image Processing
978-0-7695-3476-3/08 $25.00 © 2008 IEEE
DOI 10.1109/ICVGIP.2008.22
55
Authorized licensed use limited to: Tsinghua University Library. Downloaded on February 4, 2009 at 00:52 from IEEE Xplore. Restrictions apply.
8/14/2019 Liu Mesh Editing
http://slidepdf.com/reader/full/liu-mesh-editing 2/8
selecting a suitable scale at which to perform the editing.
The strategy of multi-scale deformation space addresses the
problem of adaptive modeling, and nodes classification fur-
ther alleviates redundant variables. We adapt embedded de-
formation algorithm in [2] by separating nodes into groups
and only optimize a part of them, which is much more ef-
ficient. Therefore, we could achieve desirable deformationresults with as few computations as possible.
We also demonstrate a novel way to build reduced de-
formable model. By constructing lattice structure and uni-
form sampling, traditional simplification algorithm which
is inefficient for large meshes is avoided and the layout of
graph nodes is well conforming to the shape of the model.
An additional advantage of the regular lattice is that it
speeds interactive process like handle selecting because the
spatial information of lattice cells makes geometrical oper-
ation of intersection over the entire mesh unnecessary.
2. Previous work
Due to the widespread availability of very detailed
scanned meshes, recent research focuses on high-quality
mesh editing with real time interaction. This paper is
the result of inspirations from previous work, including
meshless deformations [3, 4], gradient domain techniques
[5, 6, 7, 8, 9], multi-resolution methods [10, 11], Inverse
Kinematics (IK) techniques [12, 13], space deformation
[2, 14] and rigidity-based methods [1, 15].
[4] proposed Fast Lattice Shape Matching (FastLSM),
which is an extension of deformable shape matching to reg-
ular lattices with embedded geometry. The primary merit
of this algorithm is its stability and high efficiency. How-
ever, because the deformation is a dynamics simulation,there is some difficulty yielding arbitrary yet visually pleas-
ing poses. In essence, the user’s operation exerts an external
force and the goal positions of vertices are updated through-
out the process. So the end result of deformation may not
be in accordance with the user’s expectation.
Gradient domain techniques have received much atten-
tion recently, which cast mesh deformation as an energy
minimization problem. Laplacian differential coordinates
[16, 17] are widely used to preserve local details. However,
the nonlinearity makes the energy term essentially a least-
squares one and often run into serious problems with slow
convergence and numerical instability. Subspace method
[8] has been developed to achieve acceleration but it stillsuffers from high computational cost.
Multi-resolution decomposition of the original mesh fa-
cilitates detail-preserving editing at varying scales by gen-
erating a hierarchy of simplified meshes together with cor-
responding detail coefficients [10, 11]. The mesh puppetry
[13] mixes two approaches into a unified framework: the
“skinned mesh” method and mesh deformation based on
function optimization, which enables fast design of large
scale deformation while maintaining small scale features.
However, this approach can only handle articulated models,
requiring a rough skeleton of the mesh as input.
The closest work to our paper is [2], which proposed a
novel deformation representation and optimization proce-
dure. Compared with volumetric[18] or subspace structuresused by previous methods, this algorithm is much simpler
and exhibits high quality of deformation. The limitation of
the method is also evident: because deformation graph is
static during editing, it often meets with the dilemma that
the deformation graph is either too coarse to handle fine-
scale edits or so dense as to require much computation.
As the deformation is driven by user-specified handles,
handle-aware shape editing [1] computes the priori degree
of local deformation on the mesh to aid the construction of
reduced models. However, solving the Laplace Equation
to get harmonic fields is time consuming. [15] performs
rigidity analysis among the lattice cells generated over the
mesh similar to our work, but its nonlinear volumetric en-ergy inherently requires a costly optimization and the RBF
interpolation is also prohibitive.
Our work harnesses the flexibility of space deformation
and the idea of rigidity-based editing. The priori rigidity
estimated by Fast Lattice Shape Matching helps to build a
dynamic deformable structure whose scale is selected auto-
matically according to the handle configuration, maintain-
ing computational cost relatively low for both coarse-scale
and small-scale deformations.
3. Multi-scale deformation graph
We now describe the lattice structure and deformation
graph used in our system. By constructing lattice struc-
ture we build a connection between control nodes and lat-
tice cells (mesh vertices as well) that intersect the boundary
surface of the model (named surface cell). The graph nodes
of the finest scale can be made either denser of sparser by
adjusting parameters conveniently.
3.1. Lattice structure
The input to our system is a triangle mesh M with ver-
tex position and connectivity information. After loading the
mesh model, we build a lattice of cubic cells enveloping the
entire object (Figure 2). By adjusting width parameter w of
lattice cell, the number of cubic cells is changed, which af-
fects the resolution of deformation graph. We encode each
vertex with another group of integer coordinates (wi, hi, di)
565656
Authorized licensed use limited to: Tsinghua University Library. Downloaded on February 4, 2009 at 00:52 from IEEE Xplore. Restrictions apply.
8/14/2019 Liu Mesh Editing
http://slidepdf.com/reader/full/liu-mesh-editing 3/8
Figure 2. Models and their lattice structure.
which associate vertex i with its corresponding cell:
wi = ⌊(vix − xmin + 0.5w)/w⌋
hi = ⌊(viy − ymin + 0.5w)/w⌋ (1)
di = ⌊(viz − zmin + 0.5w)/w⌋
where (vix, viy, viz) is the position of vertex i,
(xmin, ymin, zmin) is the lowest boundary coordinates
of the model.
The purposes of constructing lattice structure are to es-
timate rigidity of mesh surface and to build reduced de-
formable model. We treat the mesh as a solid object and
fill the inner part so that shape matching algorithm could
simulate the deformation of real volumetric model. As in
[14], Lattice deformation is controlled by particles placed
at the center of each lattice cell. Each particle has static
initial position x0i , dynamic position xi and goal positiongi. We also construct neighborhood list Li of cell i: only
if two surface cells share at least one mesh edge, can they
be included in each other’s neighborhood list. Because the
structure considers the geodesic distance to some extent, we
are able to deform one region without influencing the other
no matter how close they are as long as their geodesic dis-
tance is far.
3.2. Deformation graph
Deformation graph consists of control nodes and edges
connecting nodes that have influences on the same vertex.
Our system randomly selects one vertex within each surfacelattice cell as control node to construct deformation graph
of the highest resolution. We refer this structure as DG1
in which each node and its corresponding particle share an
equivalent index. We neglect the nuance of their rigidity
since the finest granularity of computing is one cell.
In this way, we avoid the process of mesh simplification
from scratch on raw model data, which is slow for large
Figure 3. Deformable structure of Armadillomodel. For a clear view of the deforma-tion graphs, we omit some graph edges forDGi (i = 2, . . . , N ) while DG1 is intact.
meshes and can not guaranty a sufficiently uniform distri-bution of nodes. DG1 meets this requirement because the
surface cells have already formed a well uniform layout.
On the basis of DG1, simplification algorithm like edge
collapse is employed to produce graphs of lower resolution,
creating a space of scales labeled subsequently as DGi (i =1, 2, . . . , N ) from the densest to the coarsest (Figure 3). We
first determine N according to N = ⌊D1/P⌋ where D1
is the node number of DG1 and parameter P indicates the
node number of the coarsest graph. The node number Di of
DGi (i = 2 , . . . , N ) is computed by Di = round{D1/i}.
4. Shape matching and scale selection
Shape matching delivers both excellent speed and ro-
bustness suitable for video games. With linear-time sum-
mation algorithm for lattice shape matching (FastLSM in
[14]), large lattices can be simulated in linear time. There-
fore, we exploit the algorithm of FastLSM to estimate the
rigidity of mesh surface.
4.1. Dynamics
The simulation of shape matching [3] is a dynamic phys-
ical process where model is deformed under external forces.
At each time step, rotation and translation matrix Tr =[Rr tr] ∈ R
3×4 is found for each region comprised of a
set of shape matching particles. Each particle’s goal posi-
tion gi is computed as the transformation of the particle’s
rest position x0i :
gi =1
|Ri|
r∈Ri
Trx0i (2)
575757
Authorized licensed use limited to: Tsinghua University Library. Downloaded on February 4, 2009 at 00:52 from IEEE Xplore. Restrictions apply.
8/14/2019 Liu Mesh Editing
http://slidepdf.com/reader/full/liu-mesh-editing 4/8
where Ri is the set of regionssharing particle i. Then, parti-
cle velocities vi and deformed position xi at next time step
are updated by
vi(t + h) = vi(t) +gi(t) − xi(t)
h+ h
f exti (t)
m(3)
xi(t + h) = xi(t) + hvi(t + h) (4)
where m is the unit point-mass uniform for all particles,
h is the time step and f exti (t) is external force defined by
f exti (t) = −const(xi(t) − x0i ). In the process, regions
associated with fixed handles are fixed in place while others
are free to deform. Particles associated with the moveable
handle are assigned an initial velocity v0 whose direction
is randomly set. The values of const and v0 are relative
to the scale of model and experimentally determined so as
to yield a reasonable deforming process. Because we only
hope to obtain the propagation path of deformation, it does
not matter what the direction of v0 is and what deformation
result the simulation will produce.
4.2. Scale selection
The deforming extent of particle i (also node i of DG1)
is defined as the maximal distance between goal position gi
and rest position x0i within a time interval:
ei = maxn=1,...,S
gi(t0 + nh) − x0i
(5)
where t0 is the starting time and small value of ei implies
high rigidity. After S time steps, assume eh belongs to the
particle specified by the moveable handle, each ei is nor-
malized by eh, obtaining e′i that implies the relative rigidity
of particle i compared with the edited particle.
Using the relative rigidity, we have a general idea of thescale of deformation, which is helpful to select an appro-
priate deformation graph. The insight of multi-scale de-
formation is that a dense graph is necessary for fine-scale
editing while a coarse one is efficient for large-scale defor-
mation. Our method is to separate the set of particles (also
the nodes of DG1) into two groups by threshold T, the first
group indicates regions-of-interest which have more signifi-
cant deformation than regions denoted by the second group.
We observe that even if all the nodes are included in op-
timization procedure, the second part exhibits visually lit-
tle transformation, therefore its corresponding nodes can be
removed from optimization. Figure 4 shows examples of
dividing propagation path of deformation when the fixedand moveable handles have been specified. The underly-
ing assumption is that the moveable handle at regions with
relatively low rigidity like limb ends implies local editing
while handle at regions with relative high rigidity like body
implies broad editing. Assume particle number of the first
group is P 1, the scale s is computed by
s = min{i |P 1 < i × P} (6)
where i is an integer and parameter P = 100 in our sys-
tem. In this way, the number of control nodes included in
optimization procedure is maintained around P.
As for the computation of threshold T, we assume that
the rigidity of fixed handles implies a boundary in the sense
that vertices associated with fixed handles should be kept
still, thus getting the threshold T. For instance,
T = max{0.1, e′} and e′ = max{e′i |e′i < 0.5} (7)
where i ∈ fixed node ids. In the case when e′ dose not exist,
we assign it to be 0.5. Because not all of the nodes will be
optimized, we divide control nodes into three classes: nodes
associated with fixed handles are classified as “Half Free
Class”. For the rest nodes, those that have relative rigid-
ity above threshold T are classified as “Totally Free Class”;
the remaining nodes all belong to “Fixed Class”. Our op-
timization routine aims at the controllable nodes subject to
the first two classes.
5. Constraints and optimization
Once we have determined a specific scale of deformation
graph DGs, the following operations are basically similar
to [2]. But the primary distinction lies in the different han-
dling of nodes subject to different classes.
5.1. Preparation
Space deformation is defined by a collection of affine
transformations associated with deformation nodes in R3.
The affine transformation of node j consists of 3 × 3 ro-
tation matrix Rj and 3 × 1 translation vector tj . Assumenode positions are given by gj ∈ R3 and set N ( j) contains
neighboring nodes of j, the transformation centered at node
j maps a 3D point p to deformed position p′ according to
p′ = Rj(p − gj) + gj + tj (8)
The transformation also has influence on node j itself which
makes the deformed position g′j simply equal to gj + tj .
Deformation graphs of all scales obey the rule that the
influence of deformation graph on a particular vertex i is
limited to its k nearest nodes as follows:
v′
i
=k
j=1
wj(vi)Rij(vi − gij) + gij + tij (9)
n′i =k
j=1
wj(vi)Rijni (10)
where v′i and n′i are the deformed position and normal, gij
is vertex i’s j-nearest node with rotation matrix Rij and
translation vector tij . The influences of k nearest nodes
585858
Authorized licensed use limited to: Tsinghua University Library. Downloaded on February 4, 2009 at 00:52 from IEEE Xplore. Restrictions apply.
8/14/2019 Liu Mesh Editing
http://slidepdf.com/reader/full/liu-mesh-editing 5/8
Figure 4. Nodes partition for Penguin model. (a)(d) show the layout of handles: yellow handlesindicate the moveable parts, red handles indicate fixed parts. (b)(e) present the division of cells(particles): yellow part belongs to the first group (deformable) and red part belongs to the secondgroup (not deformable). (c)(f) show the deforming extent estimated for each node.
on vertex i are blended linearly using weight wj(vi). The
weights for each vertex are pre-computed according to
wj(vi) = (1 − vi − gij/dmax)2 (11)
and normalized to sum to one. In the formula, dmax is the
distance to the k + 1-nearest node from vertex i and we use
k = 4 for all scales. Note that the connections between
vertices and nodes are created based on the neighboring re-
lationship among surface cells under lattice structure, thus
avoiding the topology problem to some extent.
5.2. Constraints
After all nodes of DGs have been classified, the number
of classes is denoted by Nc and different nodes are handled
differently: node of “Totally Free Class” contains 12 vari-
ables (rotation and translation), “Half Free Class” node has
9 variables (rotation only) and “Fixed Class” node contains
no variables. Our optimization procedure aims at nodes be-
longing to the first two classes.
Rotation constraint
This constraint serves the purpose of preserving detail fea-
tures, which requires the 3 × 3 rotation matrix R to be an
orthogonal matrix. This requirement is encoded by the ro-
tation error Rot(R):
Rot(R) = (c1 · c2)2 + (c1 · c3)2 + (c2 · c3)2+
(c1 · c1 − 1)2 + (c2 · c2 − 1)2 + (c3 · c3 − 1)2 (12)
where c1, c2 and c3 are the 3 × 1 column vectors of R.
Summing up Rot(R) for all the deformable nodes produces
an energy term
Erot =
Nc−1
j=1
Rot(Rj) (13)
Coherence constraint
This constraint is to regulate propagation of deformation on
the mesh surface. Here we treat deformation graph as a di-
rected graph where edge ( j, k) is differentfrom edge (k, j).Besides that transformations of nearby nodes have overlap-
ping influences on the same vertex, these transformations
also have consistent effect on each other, which is encoded
by squared distance between node j’s transformation ap-
plied to its neighboring node k and node k’s transformation
applied to itself. For edge ( j, k),
E(j, k) =Rj(gk − gj) + gj + tj − (gk + tk)
22
(14)
Furthermore, we assign weight αjk to E(j,k) to enforce
consistence constraint when large-scale deformation is ex-
pected. For editing of local detail features (when DG1 is
selected and there is one fixed handle geodesically closeenough to the moveable handle), each αjk is assigned 1,
otherwise αjk is computed according to the following steps:
• Through linear transformation from interval (el, ef )to (1, 4), map ei to weight ωi. ef , el are the largest
and smallest values of “Totally Free Class” nodes.
• Check if both node j and k belong to “Totally Free
Class”. If so, αjk = min(ωj, ωk), otherwise αjk = 1.
The term Ecoh sums all the E(j,k) as:
Ecoh =
(j, k)∈E
αjkE(j, k) (15)
where E is the set of edges satisfying that either node j or
node k, or both belong to “Totally Free Class”. Note that
the values used above are parameterized and we exclude
two cases in which E(j, k) =(Rj − I)(gk − gj)
22
: node
j is subject to “Half Free Class” and node k is subject to
either “Half Free Class” or “Fixed Class”. Here, if node jis surrounded merely by nodes of “Fixed Class” and “Half
595959
Authorized licensed use limited to: Tsinghua University Library. Downloaded on February 4, 2009 at 00:52 from IEEE Xplore. Restrictions apply.
8/14/2019 Liu Mesh Editing
http://slidepdf.com/reader/full/liu-mesh-editing 6/8
Figure 5. Deforming effects of bending theHorse’s leg. Deformed 1 is the result of oursystem, Deformed 2 is produced when termE(j, k) associated with red handle is included,Deformed 3 is induced by excluding “HalfFree Class” nodes from optimization.
Free Classes”, the optimized result of its rotation matrix is
an identity matrix whether or not term E(j,k) is removed.
If node j is placed at the boundary between fixed and de-
formable parts, removing this term allows it more degreeof freedom which is helpful for simulating deformations
near joints. In Figure 5, the red handles denote the posi-
tion where we want to bend the Horse’s leg. If we preserve
the term E(j, k), less satisfactory deforming result will be
produced. Figure 5 also demonstrates the reason why we
allocate rotation variables to nodes specified by fixed han-
dles. If we completely fix them, the deformation nearby will
be badly restricted, producing even worse results.
Position constraint
Users are allowed direct manipulation of the mesh by se-
lecting and dragging handles. Before starting the optimiz-ing procedure, vertices associated with dragged handles are
determined and their user-specified positions are computed
in 3D world. The position constraint forms the term Econ:
Econ =
p
l=1
v̄index(l) − ql
22
(16)
where vertex v̄index(l) is the deformed position of vindex(l),
ql is the user specified position and p is the number of con-
strained vertices specified by the controlling handle.
5.3. Optimization
We cast the deformation into a nonlinear energy min-
imization procedure which yields high quality editing re-
sults. The optimization problem is:
minR1,...,Rm+q;t1,...,tm
wrotErot+wcohEcoh+wconEcon (17)
Here, m is the number of nodes from “Totally Free Class”
and q is the number of nodes specified by fixed handles,
Figure 6. We perform Edit 1 similar to theone shown in Figure 8 of [13] where the Ar-madillo’s arm is twisted. The deforming re-sult is of comparable quality. Edit 2, 3 and4 also demonstrate that our system couldachieve much delicate deforming results.
leaving 12m + 9q free variables to be optimized. The
weights wrot = 1, wroh = 10, wcon = 100 in our system.
We use iterative Gauss-Newton algorithm to solve this opti-
mization problem [19] and Cholesky factorization to solve
sparse linear system [20].
6. Results
We test our algorithm in interactive applications includ-
ing both small-scale editing and large-scale editing. By se-
lecting a suitable scale of deformation graph, our system
can yield high quality deformation with high efficiency.
6.1. Small-scale editing
Figure 6 demonstrates that our system allows fine scale
editing and preserves detail features very well. Althoughthe algorithm of [2] could achieve the same results by using
a dense deformation graph, it could not change the resolu-
tion of graph during editing and the computational cost is
rather high. On the other hand, a coarse graph will bring
undesirable deforming result in some cases (see Figure 7).
Our method copes with this dilemma through dynamic scale
selection from multiple scales, allowing the user to build as
dense a deformation graph for DG1 as possible.
606060
Authorized licensed use limited to: Tsinghua University Library. Downloaded on February 4, 2009 at 00:52 from IEEE Xplore. Restrictions apply.
8/14/2019 Liu Mesh Editing
http://slidepdf.com/reader/full/liu-mesh-editing 7/8
Figure 7. Comparison of deforming effectsusing our algorithm and that of [2].
Figure 7 displays one case where a sufficiently dense de-
formation graph is needed. In small-scale editing, denser
nodes provide more flexibility and expressibility. Coher-
ence constraint enables neighboring nodes to regularize the
deformation of each other. If graph nodes are sparse, we
could not implement as fine editing as we like. In the case of
deformingthe mid toe of Penguin, our system automatically
selects DG1 whose resolution is high enough to distinguish
between target toe and other toes. When using original al-gorithm in [2] with a single but coarse graph, the movement
of mid toe has undesirable influence on the others.
6.2. Large-scale editing
In the situation where large-scale editing is performed,
a dense graph may also produce comparable deforming re-
sults to a coarser one, but the computational cost is much
higher. In Figure 8, we deform models through both small-
scale and large-scale editing, which further demonstrates
the adaptability and flexibility of our system. From the re-
sults, it is also clear that embedded deformation could pre-
serve details as well as traditional Laplacian reconstruction.
However, it is more efficient because the computational cost
is determined by the density of control nodes rather than
vertices of the mesh model.
6.3. Efficiency
The primary merit of our system lies in its adaptabil-
ity and high efficiency: dynamically updating deformation
graph according to pre-estimated rigidity and effectively re-
ducing the computing complexity. Table 1 shows the perfor-
mance of our system. It is clear that our algorithm adapts
to the manipulation attempted by the user intelligently andconfines computational cost much low. The estimation of
rigidity is the bottleneck of our system as it takes about
20 frames for shape matching to propagate deformation of
the constrained region over the entire mesh. Fortunately,
this computation is done only when the layout of handles is
changed instead of during every interactive manipulation.
Table 2 shows a comparison to closely related tech-
niques, which demonstrates the advantages of our method.
Figure 8. We modify the shapes through bothlarge-scale and small-scale editing.
The combination of multi-scale deformation graph and
nodes classification renders a better editing results at lower
computation cost compared with single and static graph
(containing 220 nodes) used in [2]. Besides, our method
provides faster interactive speed for handle selection. As
for FLSM in [4], it is true that it could quickly converge to
a solution per frame, but it usually takes at least 10 frames
to obtain a comparable extent of deformation and the result
could not strictly conform to the user’s desire. Furthermore,
its cost of updating vertices positions is much higher than
our linear blending. For algorithm in [15], its bottleneck
lies in the RBF interpolation which requires several seconds
for large meshes with 50K + vertices; the rendering time is
also more than ours. Note that the performance data of al-
gorithm [15] in Table 2 pertains to a 50K vertices model,
which is much smaller than our Armadillo model.
7. Conclusions
We have presented an intuitive multi-scale approach for
mesh editing. Our system builds a dynamic and intelligent
deformable structure, which could be applied to other sub-
space deformation frameworks. We demonstrate how to
pre-estimate rigidity of the graph nodes using shape match-ing, how to use this priori knowledge to select an appropri-
ate scale of graph and organize control variables for high-
quality, high-speed editing. Our main idea is to let the res-
olution of deformation graph match the complexity and ex-
tent of deformation, which is more efficient than the original
algorithm and can easily meet the need of fine scale editing
which a coarse graph could not handle very well.
There remain some limits which need further research.
616161
Authorized licensed use limited to: Tsinghua University Library. Downloaded on February 4, 2009 at 00:52 from IEEE Xplore. Restrictions apply.
Recommended