Patent Application
20150242546
The Provisional U.S. Patent Application Ser. No. 61/767,702 and all the reference papers are incorporated by reference into this disclosure as if fully set forth herein.
A method of cloth simulation using a constrainable multigrid is provided. The method comprises steps of:
a) mapping information of geometry of N material points, of the cloth into a mesh of nodes, having a 3N position vector x, a 3N×3N mass matrix M, and a 3N velocity vector v;
b) calculating a change of geometry of the mesh of nodes at a plurality of time steps using a multigrid method by solving a time-varying partial differential equation at multiple resolutions or levels; and
c) providing a hierarchical mesh through restriction or coarsening by down-sampling from level m to m−1 or prolongation or interpolation by up-sampling from level m to m+1;
d) transferring soft constraints between different hierarchical levels using a damper-based constraint method;
e) updating the position vector x and the velocity vector v of the mesh nodes; and
f) displaying an updated state of the mesh of nodes using updated position vector x and velocity vector v on a display,
wherein the coarsening of mesh is performed by coarsening a system matrix of the time-varying partial differential equation through the damper-based constraint method,
wherein the system matrix is changed by damper matrices and displacement forces.
The time-varying partial differential equation may be given
The mesh may be triangular, wherein the step for providing a hierarchical mesh comprises a constrained Delaunay triangulation to generate finer or coarser meshes, and wherein for prolongation each triangle having three parent particles at level m is subdivided into four smaller triangles by inserting mid-particles at mid-points of three edges, and for restriction the mid-particles are removed.
A 3×3 damper matrix Di, a directional damper, constrains particle is movement along a particular direction by being added to a block diagonal term of the system matrix in
The Di may be given
The directional damper may be a sum of a 3×3 orthogonal projector and a 3×3 complementary projector.
The displacement force may be given by
The step for transferring soft constraints to a coarser levels from level m+1 to level m may comprise a step for determining which particles are constrained in level m, for each constrained particle which type of constraint is to be used, and what value is used for constraint coefficients.
Coarsening may be applied recursively until a desired coarser level is reached.
The method may further comprise a step for performing a plurality of relaxations to reduce residual errors at each level, wherein the step comprises a preconditioned conjugate gradient scheme and a Gauss-Seidal scheme.
The step for providing a hierarchical mesh may be performed by an algorithm
Algorithm 1.
The patent or application file contains at least one drawing executed in color. Copies of this patent or patent application publication with color drawing(s) will be provided by the Office upon request and payment of the necessary fee.
These and other features, aspects and advantages of the present invention will become better understood with reference to the accompanying drawings, wherein:
We present a new technique which can handle both point-to-point and sliding constraints in the multigrid framework. Although the multigrid method can theoretically perform as fast as O(n), the development of a clothing simulator based on the multigrid method has been facing a major challenge: handling the constraints. Resolving constrains has been difficult in the multigrid because there has been no clear way to transfer the constraints existing in the finest level mesh to the coarser level meshes. This paper presents a new formulation based on soft constraints, which can transfer the constraints defined in the finest level to the coarser levels. Experiments are performed which show that the proposed method can solve the linear system up to 3-9 times faster in comparison with the modified preconditioned conjugate gradient method (MPCG) without quality degradation. Relative speed up with respect to MPCG is not sensitive to the amount of constraints in the system. The proposed method is easy to implement and can be straightforwardly applied to existing clothing simulators which are based on implicit time integration.
REALISTIC, fast clothing simulation techniques have been an important issue in the computer graphics field over the past twenty years. Thanks to the achievements made in this field, it is now possible to create simulated clothing that is almost indistinguishable from real clothing. Such kinds of high quality clothing simulations call for some amount of computation thus are done in off-line, and used in the production of movies or feature animations. On the other hand, there are also some applications (e.g., gaming, on-line personalized clothing sales) in which realtime performance is important. The draping quality trades off with simulation speed. Nonetheless, as the clothing simulation technology is exposed to a wider audience, a strong demand has emerged for a realistic and fast simulation technique. This paper proposes a technique which can produce production-quality clothing simulations several times faster than previously proposed methods.
Simulation of clothing interacting with a body and objects can introduce thousands of sliding or point-to point constraints. The the preconditioned conjugate gradient (MPCG) method, which was introduced by Baraff and Witkin [1], has been a practical choice for solving large sparse systems of linear equations arising in clothing simulations, particularly for its capability of resolving constraints. Other approaches have been also practiced to resolve constraints; Bridson et al. [2] and Muller et al. [3] resorted to direct position/velocity manipulation.
Multigrid (MG) methods [4], [5], which use multiple resolutions (or levels) to solve a linear system, have been successfully applied to various problems such as fluid dynamics, image processing and deformable objects. When applied successfully, MG methods exhibit optimal (linear) time complexity. Unfortunately such optimal performance is not straightforwardly achievable in clothing simulation. A major challenge here is constraint handling; The simulators which have been developed based on the MG framework do not have proper constraint handling capability. We note that the above projection-based hard constraints, whether resolved while solving the linear system (MPCG) or after solving it (position alteration/velocity filtering), cannot be easily transferred between hierarchical levels, as it is difficult to decompose projections into sum of fine-level projections. Considering the smooth nature of the inter-level quantity exchanges (e.g., in interpolation and coarsening), we conclude that hard constraints are not suited for MG simulations.
This paper attempts the use of soft constraints, which can be implemented through the implicit filtering mechanism of the implicit time integration. We find that this new method handles sliding constraints and point-to-point constraints remarkably well in the MG framework. In handling the sliding constraints, the proposed method allows to add the effect of friction in a very simple way. Although the method is formulated with soft constraints, the experimental results show that the constraints resolution quality measured at the finest level is visually indistinguishable from ground-truth simulation results obtained by the MPCG method. Judging the overall simulation, there is no loss of quality compared to MPCG but runs up to 3-9 times faster depending on the mesh size. Relative speed up with respect to MPCG is not sensitive to the amount of constraints in the system.
The contributions of this paper are 1) the development of a new multigrid framework for clothing simulation which can accommodate constraints, and 2) the development of a particular procedure to transfer constraints between multigrid levels.
There exist numerous works on improving the quality of clothing simulations. For brevity, we review the most relevant work to ours, and refer readers to [6], [7].
Since the seminal work of [1], implicit time integration has been a popular choice for high-quality off-line simulations.
To enhance accuracy, more refined methods such as the second order backward difference formula (BDF2) [8] and midpoint implicit integration [9] were tried. The framework has been enriched by various energy models [10], [11], [12], [13], [14] that could reproduce realistic movements of clothing materials.
Constrained dynamics have been widely investigated in computer graphics. Witkin et al. [15] classified the types of constraints and employed a penalty method to prevent illegal particle motions. Baraff and Witkin [1] presented the MPCG method that filtered out undesired particle DOFs during preconditioned conjugate gradient (PCG) iterations. Constrained Lagrangian mechanics were used for handling contact [16], for strain limiting [17] and for controlling cloth motions [18]. Unlike these approaches that integrate constraints as part of the system equation, Bridson et al. [2], Muller et al [3] and Thomaszewski et al. [19] treated constraints in the post-processing step after solving the linear system.
Hierarchical approaches have been studied for the purpose of improving performance. Muller [20] proposed a hierarchical solver that improves convergence and speed of realtime cloth simulation based on the position based dynamics [3]. Wang et al. [21] developed a multi-resolution solver that improves global convergence in the strain limiting steps during deformable object simulations. Those two solvers used hierarchy only for resolving constraints, whereas Lee et al. [22] solved reduced versions of the implicit integration equation with dynamically adaptive meshes.
Multigrid (MG) method has proven to be effective for regular domain in various fields such as fluid simulation [23], elastic body simulation [24], [25], and image processing [26]. For unstructured mesh, one can use algebraic multigrid (AMG) or geometric MG on hierarchically defined meshes. AMG constructs hierarchy of operators directly from the system matrix [27], while geometric MG directly controls the structure of hierarchical meshes. The present work is based on the geometric MG method as in [28], [29].
The standard multigrid methods are not directly applicable to clothing simulations (see Section 3.1 for the details). Oh et al. [29] proposed to use physically inspired coarsening techniques. Although the method only coarsened forces and Jacobians, it left the constraints unprocessed through the multigrid levels, resulting in poor convergence when there exist a large set of constraints. Lee et al. [22] overcame the problem by adaptively changing meshes, which led to improvements in the performance. However, the performance and accuracy of their method depended on the error correction step which is applied at the finest level. When a fixed number of correction steps were applied, the method may not guarantee the the desired precision (e.g. below residual error 1.e-5). McAdams et al. [25] used (an)isotropic Young's modulus for modelling constraints in character skinning animation and applied that model to multigrid. Although soft constraints are used in multigrid framework, their coarsening model is based on regular hexahedral lattice and is not directly applicable for simulating the frictional sliding between object and deformable mesh.
Recently, the methods to combine physcially based coarse level simulations with efficient schemes to add fine level details have been actively studied. Muller and Chentanez [30] created wrinkles from a coarse result using efficient but approximate pseudo dynamics simulations. Wang et al. [31] and Aguiar et al. [32] used machine learning approaches to generate real-time wrinkles based on similar simulation examples for training. Feng et al. [33] and Rohmer et al. [34] achieved a detailed high-resolution wrinkling using non-linear operators, and Kavan et al. [35] used a linear up-sampling operator acquired from least square fitting of example simulation sequences. Although promising, these methods do not couple high resolution simulation back to coarser simulation, so simulation quality does not match that of fine level simulations; our method produces results that are visually indistinguishable from fine level simulations.
Physically-based clothing simulation can be formulated as a time-varying partial differential equation
where x′ is the acceleration, M is the mass, E is the scalar representing the energy associated with internal deformations, F is the sum of external forces including gravity, air-drag, constraint forces, and collision force. Employing a method of implicit integration [1], Equation (1) can be written into a linear system
where h is the time-step, M is the 3N×3N mass matrix, f is the 3N force vector which is the sum of the external forces and the internal forces stemming from the internal energy, x is the 3N position vector, v is the 3N velocity vector, n is the superscript of the time step. For direct handling of positional constraints, we use the above formulation, in which the unknowns are position changes rather than velocity changes. In the subsequent writing, we denote the left hand side of the above equation by AΔx and the right hand side by b. The system matrix A is 3N×3N block-symmetric and can be made positive definite by dropping some of the Jacobian terms when the cloth is in tensile compression [10]. Thus, this equation can be solved using iterative methods such as (preconditioned) conjugate gradient, Gauss-Seidel relaxation, or multigrid.
The purposes of this section are two folds: (1) it overviews the multigrid method in the context of clothing simulation, and (2) it describes the basic design of the multigrid framework this paper uses based on the prior work. Novel developments this paper makes for the constrainable multigrid are presented in Section 4.
The multigrid method [4], [5] is a numerical method to solve AΔx=b by solving the system at multiple resolutions (or levels) and exchanging the resulting quantities across the levels. We use the variable in to refer to the current level as shown in
Multigrid method can theoretically perform as fast as O(n). The basic idea of the multigrid method is to accelerate the global convergence by solving the residual equation in the coarser level mesh. In the standard multigrid method, the restriction operator R and the prolongation operator P are used to coarsen the system matrix, i.e., Am=RAm+1P. Unfortunately, this operation does not produce properly coarsened matrices for cloth simulation. Oh et al. [29] introduced a restriction operator suited for multigrid cloth simulation. They proposed that the system matrix could be decomposed into the mass matrix, the internal force Jacobian, and the external force Jacobian. With this decomposition, each decomposed matrix could be coarsened in a physically meaningful way. This paper adopts the decomposition, and develop additional parts which are needed to properly handle constraints in clothing simulation.
We now describe basic details in our development of a multigrid cloth simulator. We explain how the mesh is prepared for hierarchical usage, and how the smoothing, restriction, and prolongation operators are designed.
First, we employ the constrained Delaunay triangulation to generate the coarsest mesh to approximate a given cloth patterns. Second, each triangle is subdivided into four smaller triangles by inserting particles at the mid-points of the three edges, as shown in
In the standard multigrid method, a few relaxations are performed to reduce residual errors at each level. Typical choices for such smoothing steps are local iterative methods such as the Gauss-Seidel or Jacobi that quickly kill the highest frequency terms of the errors. In this paper, we present a new smoothing scheme that combines both preconditioned conjugate gradient (as a pre-smoother) and Gauss-Seidel (as a post-smoother), achieving better convergence than choice of a single method. See Section 5 for details.
For the restriction operator, we employ the full-weighting scheme used in Oh et al. [29], which evenly distributes the residual associated with a mid-particle to its two parentparticles.
For the prolongation operator, we use the linear interpolation as in the standard multigrid; the mid-particle error is given as the average errors of the two parent-particles.
Simulations of clothing interacting with a character's body can introduce thousands of constraints. Therefore, without a proper method to handle the constraints, all the benefits of using the multigrid method quickly diminishes. In a typical setting, a user supplies constraints for the finest mesh, either with direct control or indirectly through collisions. The constraints are difficult to transfer to coarser levels, since it is impossible to control the degree of constraining of the hard constraints. There is no in-between for these hard constraints; a particle is either constrained or not constrained. Ignoring the constraint altogether during coarsening step would result in the loss of some critical information for coarser level simulation.
On the other hand, if we decide to pass the constraints associated with the mid-particle onto both of its parentparticles, the coarser level movement would be more constrained than it is intended by the user. In any case, transferring the hard constraints from the finer level to the coarser level is problematic. We initially experimented with several constraint distribution strategies for a hard constraint-based multigrid method, but discovered that these methods either fail to converge or converge at sluggish rates.
In order to remedy this problem, we use soft constraints for our framework. We treat each constraint as a damper, and develop a multigrid framework based on this idea. This damper-based constraint method (DECM) is motivated by the filtering effect of the implicit time integration (Equation (2)). We constrain each particle's movement along a particular direction by adding a new term to the system matrix, in addition to the force-Jacobian term. More specifically, to constrain the movement of particle i, we add a 3×3 matrix Di (which we call the directional or omnidirectional damper based on the types of constraints) to the block diagonal term of the system matrix in the following equation
where
f
disp(fdisp,1T,fdisp,2T, . . . ,fdisp,NT)Tε3N
D=diag{D
1
,D
2
, . . . ,D
N}ε3N×3N,
We use the following formula for Di
where ni is the prohibited direction of the particle i. The directional damper is the sum of a 3×3 orthogonal projector and a 3×3 complementary projector. The orthogonal projector leaves the other two dimensional DOFs, dampening the movement of particle in the prohibited direction. kc is used to control the degree of dampening. The complementary projector yields the effect of friction on the tangential plane in
If there is a positional change that we wish to enforce along the constrained direction as shown in
f
disp,i
=D
i
d
i (5)
where di is the displacement determined by the movement of the solid object in contact with the cloth particle i. fdisp,i is named as the displacement force because it ends up producing a displacement Didi along the constrained direction. Note that Didi is not the desired displacement itself but its projected version. The addition of this force does not make the linear system unstable because that force is introduced in conjunction with the corresponding damper to the system matrix.
We note that the above method is different from the standard damping forces added to implicit integrators, even though it may appear so at first sight. In the usual damping force models, the force term on the right hand side and its Jacobian in the system matrix are always paired. In contrast, Di and fdisp,i do not necessarily come in pair; fdisp,i is added only when some displacement needs to be generated along the constrained direction. Note that we do not use the velocity Jacobian
for constraints, which can add artificial viscosity to the system if the standard spring damper was used for soft constraints.
This seemingly small deviation plays an important role in coarsening the constraints consistently across the hierarchical level meshes, when used in the context of the multigrid method along with the inter-level constraint transfer procedure introduced in Section 4.2.
We now describe how the two extra terms (damper matrices and displacement forces) are coarsened and restricted to the coarser level mesh. We describe the coarsening process for the system matrix in this section, which is demonstrated in
For usual forces and Jacobian terms, we use Oh et al.'s [29] coarsening procedure, which works on Am+1 and produces an intermediate result A˜m. At this stage, constraints are not reflected in the system.
We then transfer constraints to the coarser levels as follows. Suppose that m+1 is the current level and in is the coarser level into which we want to coarsen the system matrix. We determine (1) which particles should be constrained in level m, (2) for each constrained particle, which type of constraint should be used, and (3) what value should be used for the constraint coefficient(s). This process is completed by adding appropriate dampers to A˜m based on the above decisions, producing a coarsened matrix Am. We apply the coarsening procedure recursively until we reach the coarsest level.
Let Pm,i be an arbitrary particle in level in and let Pm+1,i be its copy in level m+1. Let Pm+1,j (j=j1, j2, j3 . . . ) be the particles that form Pm+1,i's one-ring neighborhood. Let Nm+1,i={Pm+1,i,Pm+1,j1,Pm+1,j2,Pm+1,j3 . . . } be the set of particles consisting of the above one-ring neighborhood and Pm+1,i itself. Let cm+1,i be the set of the constraints existing on the particles in Nm+1,i. Note that |Cm+1,i|=|Nm+1,i| (where ∥ denotes the cardinality of a set) since unconstrained particles may be present. The situation can be categorized into the following three cases, and we explain how Pm,i is constrained in level m for each case.
If |Cm+1,i|=0, then Pm,i is not constrained in level m.
If Pm+1,i is not originally constrained in the finest level mesh, then we constrain Pm,i with the result of blending the constraints in Cm+1,i. The constraint type of Pm,i follows the particle's type which has the maximum constraint coefficient among Cm+1,i.
If the constraint type of Pm,i turns out a point-to-point constraint, Dm,i should be an omnidirectional damper. Its constraint coefficient kc,m,i is determined by
where l is an element's index of Cm+1,l which is a subset of Cm+1,i excluding the sliding constraints. The weighting factor ωl can vary with the interpolation scheme. We found 0.5 for the particles Pm+1,j and 1.0 for the particle Pm+1,i worked well. When the weighted sum exceeds a original coefficient of point-to-point constraint in the finest level, the value is clamped to prevent the coarse level particle from being excessively constrained.
If the constraint type of Pm,i turns out a sliding constraint, Dm,i should be a directional damper. In a directional damper, we need to determine the constrained direction, constraint coefficient and frictional coefficient as in Equation (7) and (8).
where l is an element's index of Cm+1,l which is a subset of Cm+1,i excluding the point-to-point constraints. The constraint coefficient and frictional coefficient are determined as in Equation (8) and the weighting factor ωl is determined in the same way as in the point-to-point constraint case.
If Pm+1,i is originally constrained in the finest level mesh, we let Pm,i have the same constraint type and damper as Pm+1,i has, regardless of the presence of additional constraints in Nm+1,i. The rationale here is that the nonoriginal constraints created in the coarse level m<M are for emulating the original constraints. If Pm,i is originally constrained, then that original constraint is precisely what is desired for Pm,i in level m, thus blending any other constraints is not necessary.
The displacement forces are not different from usual forces on the right hand side b of the linear system for multigrid purposes. So they are restricted with the full-weighting scheme used in the standard multigrid method [5].
Algorithm 1 summarizes our multigrid solver Multigrid( ) which calls V-Cycle( ) in Algorithm 2 repeatedly until convergence. Better performances could be obtained using two different types of smoothers, namely, the PCG method and the Gauss-Seidel method; The PCG method is used for the pre-smoother (the smoother for the downstroke of the V-cycle), and the Gauss-Seidel iteration (GS) is used for the post-smoother (the smoother for the upstroke), as shown in Algorithm 2. The rationale behind using the mixture of PCG and GS for smoothing is to combine the advantages of each iterative method. For the case of cloth simulations, PCG is better than any other smoothers in global convergence. In the down-stroke, in fact, PCG is effective in reducing the overall frequency components of the error at each level. GS, on the other hand, is a local smoother that very quickly dampens out high-frequency components of the error without vitiating other frequency error components. This property of GS works effectively in the up-stroke. As shown in
In the pre-smoother step and the coarsest solver, we use PCG with a 3N×3N block diagonal preconditioner (Jacobi preconditioning), and in the post-smoother step, we use a 3×3 block-wise Gauss-Seidel method. GS is parallelized by adopting a multi-coloring algorithm in a triangular mesh [37]. For simplicity, we just apply same colors to the particles that are not updated simultaneously. Each set of same colored particles are updated in parallel. For PCG and MPCG, we also parallelize mat-vec multiplications for a fair comparison for all experiments.
The V-Cycle involves two different iterative methods, thus the stopping criteria need some consideration. Typically, the PCG method uses r|Pr to check for convergence, where P is the preconditioner and r is the residual r=b−AΔx. On the other hand, the GS method would use r|r. For consistency, we measure residual errors with r|Pr in both Algorithm 1 and 2.
We implemented the proposed method for parallel performance using OpenMP. All simulations were performed on a single desktop computer with Intel Core i7(3930K) 3.20 GHz CPU and 12 GB RAM. Final rendering (except for the real-time footage) was done with V-ray and Maxwell via Maya. For implementing the clothing simulator, we used the triangle-based energy models [1] for the in-plane deformation and the hinge-based model [11] for the out-of plane deformation. For the time integration, we employed the second order backward difference formula [8]. Although we formulated our method based on the first order backward difference formula, extending to the second order is straightforward.
Collision handling can be classified into two categories; solid-cloth collision and cloth-cloth collision. For solid cloth collision, we detected the penetrations between cloth's vertices and solid's triangles. For the case of contact, we applied the (frictional) sliding constraints on the vertices which were in contact with solid's surface. For cloth-cloth collision, we handled both triangle-vertex and edge-edge collisions. (In the production of the real-time footage, we ignored cloth-cloth collisions.) Unlike solid-cloth collision, cloth-cloth collision is not an obstacle in developing a multigrid framework. As addressed in [29], for the colliding vertex-vertex pairs, we applied strong spring forces to push them apart. The spring force and its Jacobian can be incorporated into multigrid framework in the same way as the triangle-based forces. We adopted [38] for calculating the repulsive and attractive forces and [2] for the postprocessing after solving the linear system.
For checking the convergence in all simulations reported in this paper, we referred both relative and absolute residual errors, the stopping criteria being 10-4 and 10-5, respectively. If the initial L2 norm of residual is too small for the case of almost reaching a static state, relative error criterion is unnecessarily excessive. Thus, the iteration terminates if either of the errors is below the criteria.
We experimented our method with various cloth and clothing examples ranging from simple handkerchiefs to complex garments as shown in
The speed-up of MG with respect to MPCG does depend on the mesh complexity of the finest level mesh. We constructed the one-piece with increasing mesh complexities as shown in Table 2 and ran MPCG and MG, holding other conditions the same. The table demonstrates that the speedup increases as the mesh complexity increases. (Although the speed up depends also on the time step size, the material properties, and the design of the outfit, the dependency on those factors is minor and does not exhibit any clear tendency compared to the mesh complexity.)
This table summarizes the statistics in simulating the seven scenes of
number of total frames (time steps), the material properties of cloth, constraint coefficient, the stopping criteria for the relative and absolute errors, the number of pre-smoothing and post-smoothing in one V-Cycle, the average number of V-Cycles per each time step, the average
computation time per each time step. The average computation time here measured only the time taken for solving the linear system.
This table summarizes the time taken by the MPCG and the proposed method (MG) in simulating the One-piece at different mesh complexities. The numbers shown in the second and third rows are the time (in msec) taken for simulating one simulation time step. The simulation time step size was 11.11 msec. We used 100, 10, 0.01, 1e-5 for the stretch stiffness, shear stiffness, bending stiffness, density of cloth, respectively.
Our constraint method (DBCM) presented in Section 4.1 produces soft constraints, whose intensity can be varied with the coefficient kc. We typically set kc=100, a value comparable to the tensile stiffness. With this, the effect of the soft constraint is practically indistinguishable from hard constraints. Table 3 reports how much errors exist in the constrained particles that should stay fixed or slide on a plane. We measured displacements from the constrained configuration (point or plane) for all the constrained particles during the entire simulation. The table shows that, with kc=100, the maximum error stays within the collision offset (0.2 in the normal direction), which is more than enough to maintain stable contact between cloth and body.
In addition, since DBCM is based on soft constraints, it is possible to produce the effect of friction very easily as described in Section 4.1.
This table shows how closely the soft constraint of the DBCM emulates the hard constraint. We measured the (maximum displacement) error of the constrained particles at different values of kc. The unit of the error is in centimeters.
Convergence is one of the most important issues in developing an iterative linear system solver. The system matrix of Equation (3) is symmetric positive definite and block-diagonally dominant, since we added a positive block diagonal matrix D to the existing system matrix of Equation (2). The same is true for the coarsened system matrices in the lower levels. Thus, the linear systems of all levels always converge by either PCG or GS itself.
In the proposed multigrid method, however, applying a fixed number of post-smoothing (e.g. 10) in a V-Cycle always does not guarantee that residual error optimally decreases in that V-Cycle. If the current residual error in the V-Cycle is not below the some criteria (e.g. the residual error at the beginning of the V-Cycle), additional post smoothing iterations (e.g. 1020) are applied. In Sphere Test 2, the crumpled cloth (
In those cases, the correction procedure in the coarse grids may not be a great help for improving the finest level solution, since what is happening in the lower level does not properly approximate the situation happening in the finest level. It is an intrinsic problem of the hierarchical approaches including the multigrid method. We attribute it to MG's non-homogeneous interpretation of the wrinkles across different levels; MG models bending in the finest level mesh as tensile compression in the lower level meshes [21], [30]. Although M=3 or 4, and V(5,10) produced satisfactory results in almost cases, further study might reveal optimal choices.
In this paper, we presented the damper-based constraint method which can handle both point-to-point and frictional sliding constraints in the multigrid framework. Because this method uses soft constraints, it can coarsen the constraints defined in the finest level to the coarser levels. We also presented how the soft constraints can be coarsened across different levels, and showed through several experiments that the proposed constraint method along with the new coarsening scheme can solve the linear system up to several times faster in comparison with the MPCG without quality degradation even in collision-intensive cases. Although we employed soft constraints, we showed that their effect is practically identical to the hard constraints which have been widely used in clothing simulation. The proposed method is easy to implement and can be applied to existing clothing simulators which are based on implicit time integration.
This application is a non-provisional application corresponding to Provisional U.S. Patent Application Ser. No. 61/767,702 for “Method of Cloth Simulation using Constrainable Multigrid” filed on Feb. 21, 2013.
