Fast Simulation of Cloth Tearing

Cloth simulation has many applications areas like computer animation, computer games or virtual reality. The simulation of cloth tearing is often a non-trivial process because it requires the capacity of dynamically updating different cloth representations and data structures. For interactive animations, this must be performed as fast as possible. We present a comprehensive description of a technique that can be used to simulate cloth being torn or cut. Despite simplistic and not physically accurate, it is fast and can provide visually pleasing results. Also, it can be easily adapted to work with nearly any cloth model. As an original contribution, we introduce an optimization of this technique by using an especially adapted half-edge data structure. We have implemented the techniques described in this paper in a physics simulator that was specially developed for a garment CAD system. Our tests have shown fast and attractive results. Keywords—Cloth Simulation, Tearing Simulation, Physics-Based Animation, Interactive Animation, Half-Edge Data Structure


I. INTRODUCTION
T HE development of stable, robust and fast methods that provide visually plausible results is the focus in the field of physics-based animation [1].As mentioned by Muller et al. [2], the creation of new methods tailored to specific needs is the primary motivation for doing research on this field.
The simulation of cloth tearing is often a non-trivial process because it requires the capacity of dynamically updating different cloth representations and data structures (see section III).And for an interactive simulation this process must be performed as fast as possible.
In this paper, we describe a technique that can be used to simulate cloth being torn or cut.Despite simplistic and not physically accurate, it is fast -suitable for interactive applications -and it can provide visually pleasing results.Furthermore it can be easily adapted to work with nearly any cloth model.
The idea behind the technique is simple and easy to understand (see section IV).Although we believe the detailed description we provide here is unique, the idea itself is not of our own making, being briefly mentioned by other authors such as Muller et al. [2] and sometimes informally discussed by the research community.However, we have employed optimizations in the standard implementation, which we discuss in section IV-B.Also, we show how the base technique can be used to achieve other results (section V).
The original contribution of this paper is the presentation of a method to optimize a well-known tearing technique for interactive cloth simulation.

II. RELATED WORK
Cloth simulation has been on the interest of the graphics community for more than two decades.There are many works addressing different aspects of the simulation.However, in this area, there are not many published studies which are focused on the tearing process.
Provot [3] -one of the most referred works on cloth simulation -uses a mass-spring system with a post processing technique to prevent springs from overstretching.The paper of Baraff and Witkin [4] is also a relevant work on cloth simulation.They use an implicit integration technique to prevent the numerical instability of approximate computations when using large time steps.The cloth is represented as a mesh of triangles and its internal forces (i.e.stretch and shear) are calculated based on the in-plane deformation of each triangle.The most common approach today, however, is to use a system of interacting particles where these forces are calculated based on distance constraints explicitly created for some of these particles.This is done by Choi and Ko [5].They propose a stable and robust system of interacting particles that deals with some of the instability noted in previous works.
Since this paper is concerned with explaining a specific technique of tearing, we do not address internal cloth dynamics.For the purposes of demonstrating our technique, we have tested it with a simple mass-spring system, similar to the one used by Provot [3].We have also used it with the PBD model proposed by Muller et al. [2], which is quite simple as well.
Metaaphanon et al. [6] propose a two-level model that is suitable for simulating tearing cloth realistically by showing cloth frays, which is usually visible when a real woven cloth is torn.Despite their results being more visually compelling than ours, we see that the technique we discuss in this paper has different motivations.We do not propose a new cloth model.Our approach is meant to be used in conjunction with an already existing model.Also, we believe that our approach is more suitable for applications where the visual effect of the cloth being torn dynamically is more important than the small details of this process.This is usually the case for interactive or real-time applications.
The description of the technique that we provide here assumes that the physics model is a system of particles connected by constraints, as those used by Provot [3], Choi and Ko [5], Muller et al. [2] and by many others.However, with some effort it can also be adapted to work with a system where the constraints are given by triangle deformation, like the one described by Baraff and Witkin [4].

III. CLOTH REPRESENTATION
Cloth simulation systems have to deal with two representations for a cloth object: one that is more suitable for the rendering process and other for the physics simulation (which depends on the chosen physics model).The rendering representation should allow efficient transferring of its data to the graphics card.Since graphics cards are designed to draw triangles efficiently, a mesh of triangles is the most common format used for the rendering representation.It is possible to use other formats, but ultimately it will have to be converted into a triangle mesh so that the video card can use it.At every frame, the mesh must be updated according to the physics representation before being sent to the graphics card.
Many methods for cloth simulation have topological restrictions of working with rectangular meshes only.However, we believe that the user of a physics simulator should not deal with the internal details of the physics models.Thus, a modern cloth simulation system should require that the user provides -in addition to some parameters to vary the simulated kind of fabric -just a triangle mesh as an initial input for the shape of each cloth patch.This mesh represents the resting state of the cloth.Internal constraints and other data required by the physics model are automatically generated based on it.Furthermore, the particles of the physics representation may have a direct correspondence to the vertices of the triangle mesh, i.e., each vertex is associated with only one physics particle.This way, the positions of the vertices on the mesh are easily updated according to the position of the particles in the physics representation.However, more complex associations between the mesh and the physics particles can be made, such as is done by Müller and Chentanez [7], for example.
To optimize the tearing technique that we describe here, we need a data structure that provides fast adjacency queries for a triangle mesh.Specifically, for a given vertex, we need to efficiently know all triangles that share this vertex.In order to achieve this, we use a data structure called half-edge.A good description of this data structure is provided by DeCoro and Pajarola [8].The half-edge representation allows us to perform many adjacency queries in constant time.In addition, the size of its internal data structures remains always the same, i.e., no dynamic memory allocation is required.These properties make the half-edge a good choice for our purposes.However, we had to make a slight modification on its standard implementation, which we explain in section IV-B.
When a cloth is torn, we need to update all these structures: the triangle mesh, the half-edge and the physics representation (constraints and particles).

IV. VERTEX SPLITTING
Vertex splitting is how we call the primitive task that we use to tear a cloth patch.Figure 1 illustrates how it works.In this example, the central vertex of a triangle mesh is chosen to be split by an arbitrary plane.A new vertex is created at the same place of the chosen vertex (in the figure it is in a different position only for illustration purposes).We use the half-edge abstraction to quickly find all triangles connected to the chosen vertex.Then, the plane is used to classify these triangles: the ones whose centers are behind the plane are assigned to the new vertex.In the example, these are the triangles numbered with 4, 5 and 6.Triangles 1, 2 and 3 remain the same.A new particle needs to be created in the physics representation.The mass of this new particle is set to be half of the original mass of the particle associated with the vertex that was split, which in turn also has its mass reduced by half.
The other part of the algorithm is to update the internal constraints, what depends on the physics representation.Basically, it is necessary to insert new stretch constraints to hold the new vertex and remove the bend constraints related to the vertex that was split.Also, constraints related to the faces behind the plane must now point to the new particle.The half-edge data structure may be used to speed up this process too.
Note that not all vertices are allowed to be split: there must be at least one face on each side of the splitting plane.If this is not the case, the routine of vertex splitting simply does nothing.

A. Tearing
Having the vertex splitting routine, tearing is simulated by a simple process.Whenever the stretching of an edge reaches a specified threshold value, we select one of the edge's adjacent vertices to be split.If both vertices can be split, we choose the one with the highest mass value.
If the overstretched edge is formed by the vertices A and B and A is the vertex chosen to be split, the splitting plane is given by the vertex A and its normal is the vector B − A.
When one vertex of an overstretched edge is split, the new configuration of physics constraints will impose the necessary velocities to separate the new particles, creating a small hole on the cloth mesh.

B. Half-Edge Modification
Besides updating the triangle mesh and the physics representation, we have to update the half-edge data structure.It is important to note that this data structure is only capable of representing 2-manifold surfaces.In Figure 2, two faces share a single vertex without also sharing an edge, which is an example of a triangle mesh that is not 2-manifold.Unfortunately, after splitting a few vertices we can end up with a mesh in this state.Fig. 2. Non-2-manifold meshes.Two faces share a single vertex (in red) without also sharing an edge: this is an example of a triangle mesh that is not 2-manifold.
Our solution to this issue -that allowed us to work with meshes even in this degenerate state -was to make a small change in the standard implementation of the half-edge data structure.
In the standard implementation, a mesh is represented as a set of vertices, a set of faces (triangles, in our case) and a set of "half-edges".Each half-edge must be linked to four features: one face, one vertex of this face, a next half-edge on that face and a "pair" half-edge, which is a half-edge on an adjacent face (see DeCoro and Pajarola [8] for more details).We added a fifth attribute to the half-edge feature, which we called "ghost pair" (see Figure 3).Initially, this attribute receives a default invalid value.Our "vertex splitting" routine for the half-edge abstraction receives two set of faces containing the indices of the faces on each side of the splitting plane (see Figure 1).The routine must then "unlink" these two sets by erasing the value of the pair of the half-edges related to the edges separating these two sets.In our modification, the value of the pair is saved in the "ghost pair" attribute before being erased.This is the only place where the ghost pair is modified after being initialized.The only routine that needs to read the ghost pair attribute is the one -called by the vertex splitting algorithm -that searches for the faces connected to a vertex.The pair is used to move to adjacent faces.So this routine simply has to also check the ghost pair when the pair attribute has an invalid value.Certainly we assume that our initial triangle mesh is a valid 2-manifold surface; otherwise, this modification will not work.
Note that without using the ghost pair, the consequence of having a mesh that is not 2-manifold is that some vertices are not able of being split when in fact they should be.In Figure 3, for example, the vertex pointed by the black arrow could not be split by a horizontal plane because the standard halfedge data structure would not find faces for both sides of the splitting plane.
Also note that the ghost pair exists only to keep working properly the routine for calculating the faces for both sides of a splitting plane while keeping the normal functionality for all other routines of the half-edge data structure, which use the regular pair.
V. SCISSOR TOOL We can use the vertex splitting routine to implement a "scissor tool" (see Figure 4).The input data for the routine that performs this task receives two rays, R A and R B , which are provided by the user when he picks two points on the screen.Each ray is defined by one starting point O and one direction vector V .
We then define a plane P passing through the point O A (starting point of R A ) and with normal vector N given by the cross product between the vector O A − O B and V A : Also, we need to define two other planes, P A and P B , that will be used as side boundaries.P A and P B pass through O A and O B , respectively, and their normals are We iterate through all triangles on the target cloth to gather only the triangles that intersects the plane P .For each triangle, we test the intersection by separating its vertices in two sets, one for each side (positive and negative) of the plane P .If the triangle does not have vertices in both sets, it is skipped.We arbitrarily decide to split the vertices in the set of the positive side of plane P .Moreover, each vertex on the positive side of plane P must also be on the positive side of both P A and P B , otherwise, the vertex is skipped.We split these vertices using the plane given by their own position and vector N as the normal.In practice, with irregular meshes, this produce the undesirable result of the mesh not being completely divided.A better result is achieved by alternating the normal vector of the splitting plane.Therefore, only for triangles that have two vertices, C and D, on the positive side of plane P , we do not use N as the normal for the splitting plane.Instead, we use where N tri is the normal of the current triangle under analysis.

VI. RESULTS AND DISCUSSION
We have implemented the techniques described in this paper in a physics simulator that was specially developed for a garment CAD system.The system provides two simulation modes: a fast and interactive one and a slower but more physically accurate.The techniques are suitable for the "fast mode", where the system requires interactive cloth simulation to allow the user to interact with a piece of clothing on a virtual mannequin (Figure 5).
In a scene like the one illustrated by Figure 6 -where a cloth patch is torn by the user -the processing time required only by the "vertex splitting" routine is generally negligible since this routine is called just in a few frames.In addition to fast, the technique produces good results.However, the final appearance depends upon the resolution of the simulated triangle mesh.
We have performed some tests in order to evaluate the performance of the splitting vertex routine.We use a scene where a hanged cloth patch is torn (similar to the one shown in Figure 6).We measure the time spent only in each call to the splitting vertex routine and we record the sum of all these measurements taken during the whole scene.We repeat this test ten times to obtain an average time value.Then, we repeat this process with triangle meshes of different resolutions.For comparison purposes, we also test an implementation that do not use the half-edge optimization.These tests were run on an Intel Core i5 at 2.8 GHz.The results are shown by Figure 7. Screenshot of the garment CAD system where the techniques described in this paper were applied.
As can be seen, even the "standard implementation" of the technique is pretty fast.In practice, our optimization with the half-edge provides a small -yet not negligible -gain of performance, which may be worth if you have very critical performance needs.Also, it is common to have the cloth mesh represented with the half-edge data structure for other purposes (not tearing).Hence, if the half-edge representation already exists, there is no reason not to use our optimization.

VII. CONCLUSIONS
This paper has presented a comprehensive description of a technique that can be used to simulate cloth being torn or cut.We have successfully applied this technique in an "interactive mode" of a garment CAD system (Figure 5).The choice of using the half-edge data structure to represent the cloth mesh has shown to be satisfactory.We have obtained faster results and the slight modification required in the standard implementation of this data structure is simple and very localized, i.e., a pretty small part of code needed to be changed.Also, all the good properties that make the half-edge a good choice for our purposes (as mentioned in section III) were preserved.
As a future work we wish to compare this technique -in terms of both speed and realism -with the technique proposed by Metaaphanon et al. [6].We would like to incorporate their model in the "realistic mode" of our garment CAD system.

Fig. 1 .
Fig. 1.Vertex splitting algorithm.One vertex is chosen to be split by an arbitrary plane (a) and then a new vertex is created (b).Triangles behind the plane are then assigned to the new vertex.

Fig. 3 .
Fig. 3.After vertex splitting execution.The same mesh of Figure 1 where the central vertex was split.The white arrows are the half-edges features.The blue arrow shows a regular pair and the red arrow shows a ghost pair.

Fig. 4 .
Fig. 4. Using the scissor tool.User picks two points on the screen to define the line segment in red.It is used to cut the waving flag.

Fig. 5 .
Fig. 5.Screenshot of the garment CAD system where the techniques described in this paper were applied.

Fig. 6 .
Fig. 6.Cloth tearing.Frames from an interactive application where a cloth patch is ripped off by the user, who grabs one vertex and drags it downward.

Fig. 7 .
Fig.7.Performance test results.This graph shows the sum of the times (in milliseconds) taken by each call to the splitting vertex routine during the scene where a cloth patch is torn by the user.We test both the standard version of the tearing technique and the half-edge optimization.We repeat the tests using triangle meshes of different resolutions.