liu mesh editing

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†[email protected], ‡[email protected]

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


978-0-7695-3476-3/08 $25.00 © 2008 IEEE

DOI 10.1109/ICVGIP.2008.22

55


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.



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




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




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




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




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




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


liu mesh editing

Documents