Image-Based Collision Detection for Deformable Cloth Models

Image-Based Collision Detection forDeformable Cloth Models

George Baciu, Member, IEEE, and Wingo Sai-Keung Wong

Abstract—Modeling the natural interaction of cloth and garments with objects in a 3D environment is currently one of the most

computationally demanding tasks. These highly deformable materials are subject to a very large number of contact points in the

proximity of other moving objects. Furthermore, cloth objects often fold, roll, and drape within themselves, generating a large number of

self-collision areas. The interactive requirements of 3D games and physically driven virtual environments make the cloth collisions and

self-collision computations more challenging. By exploiting mathematically well-defined smoothness conditions over smaller patches of

deformable surfaces and resorting to image-based collision detection tests, we developed an efficient collision detection method that

achieves interactive rates while tracking self-interactions in highly deformable surfaces consisting of a large number of elements. The

method makes use of a novel technique for dynamically generating a hierarchy of cloth bounding boxes in order to perform object-level

culling and image-based intersection tests using conventional graphics hardware support. An efficient backward voxel-based AABB

hierarchy method is proposed to handle deformable surfaces which are highly compressed.

Index Terms—Collision detection, deformable surfaces, cloth simulation, animation.

�

1 INTRODUCTION

INTERACTIVE collision detection has been an area of activeresearch in the past 15 years due to: 1) the inherent

complexity in the representation of highly deformablesurfaces and 2) stringent requirements for interactive framerates in the presence of complex geometry and dynamicinteractions between objects in a virtual environment.

Solutions to the general polyhedral intersections andrigid-body collision detection have been well covered in thecomputer graphics literature [38], [20], [29], [57], [56], [15],[43], [39], [31], [22], [19], [12], [23], [40], [30], [27], [36], [44].

Although searching for an efficient solution for theinteractive rigid-body collision detection problem is still anactive area of interest, the potential to solve the moredifficult problems prevalent in clothing and garmentsimulation is attracting an increasing number of researchersin this area. For example, Hu and Chan [21] and Chen et al.[10] have recently applied the finite elements and finitevolume methods, respectively, in order to generatemechanically realistic draping and contact dynamics oftextiles. This direction is highly motivated by a strongdemand in the design and control of human-like virtualactors and character models for interactive 3D environ-ments [56], [50], [55], [6], [54], [53], [13], [49] and, morespecifically, for interactive 3D games [34], [5].

Dynamic interference between convex polyhedra hasbeen extensively studied. The classic work in this area is theGJK algorithm [16], the Lin-Canny algorithm [29], RAPID[18] based on space efficient OBB trees and the separatingaxis theorem [17]. Chung and Wang [11] developed a fastcollision detection method based on the separating vector

concept. This method is limited to convex polyhedra and, inpractice, it has been observed to be less stable in thepresence of sharp features. Mirtich [36] proposed a robustpolyhedra collision detection algorithm V-Clip whichcontinued the work of Ponamgi et al. [40]. Alternatively,Klosowski et al. [27] proposed k-DOPs to bound a convexpolyhedron by k hyperplanes.

Flexible bodies began tomake an impact in animationwiththework of Terzopoulos et al. [46], [47], [45] andMetaxas andTerzopoulos [35]. Later, the collision detection and thedynamic draping of textiles were successfully simulated byVolino et al. [51], [50], [52]. Volino et al. proposed thecurvature method in which constant polygonal hierarchiesare built on top of a polygonal mesh by merging larger andlarger “low curvature” regions of the mesh. If the regions are“regular” enough, there is no need to perform checking forthe contours. They alsomadeuse of time and space coherencein order to dynamically maintain the proximity distance ofthe closest regions of a surface mesh.

Subsequently, Provot [41] refined the curvature methodby dynamically constructing the hierarchy of subsurfaceregions that satisfy a specific smoothness condition, calledð�; �Þ-surfaces in order to reduce the self-collision tests.Provot’s identification of ð�; �Þ-surfaces has been instru-mental in our work. We have used these results in order toresolve the test for collisions and self-collisions of highlydeformable materials by constructing dynamically adjusta-ble viewports and using graphics hardware buffers.

More recently, Vassilev et al. [49] have also resorted tohardware image buffers to construct the depth map of thehuman body in order to detect its interference with clothmodels. They reported rates in the order of 33ms periteration for the collision detection problem involvingmeshes of up to 3,840 vertices running on a 1.0 GHzPentium processor. Further progress in this area is alsofound in [14], [24], [26].

If object-space partitioning is used,and the potentialproblem due to aliasing in the image-space is taken into

IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 10, NO. 6, NOVEMBER/DECEMBER 2004 649

. The authors are with the Department of Computing, The Hong KongPolytechnic University, hong Hum, Kowloon, Hong Kong.E-mail: {csgeorge, cswingo}@comp.polyu.edu.hk.

Manuscript received 3 Apr. 2003; revised 13 Nov. 2003; accepted 19 Dec.2003.For information on obtaining reprints of this article, please send e-mail to:[email protected], and reference IEEECS Log Number TVCG-0022-0403.

1077-2626/04/$20.00 � 2004 IEEE Published by the IEEE Computer Society

consideration for more general surfaces, the collision andself-collision tests become more complex in nature. Bycomparison with the work of Vassilev et al. on similarlyconfigured hardware and higher cloth model complexitythat accounts for both self-collisions as well as collisions, wehave achieved rates on the order of 16ms per iteration. Ourmodel differs from Vassilev’s in two aspects: 1) It accountsfor all possible types of triangle intersection configurations,vertex-vertex, vertex-edge, and vertex-face, and 2) non-convex decomposition.

A human body is generally not convex as a whole. Ahierarchical partitioning must be employed when theviewing window is perpendicular to a lateral directiononto the body. Taking a sample through one of the armsmay result in multiple ranges that correspond to internalparts of the body and arms. If the nonconvex topology isknown in advance, then it is not difficult to find the depthand the normal maps of the body. However, if the topologyis not known in advance and the object is not convex, then itis difficult in general to compute the depth maps inhardware as proposed by Vassilev et al. This is whereProvot’s result on decomposing a general surface intopatches of ð�; �Þ-surfaces proves to be useful in practice andspecifically in our work.

We have built upon our work started in [4], [2], [3] anddeveloped a novel image-based method to perform collisionand self-collision detection tests for highly deformablesurfaces represented by large triangular meshes on theconventional graphics hardware. Our multiviewport algo-rithm performs collision detections on deformable surfacesin excess of 50,000 elements and robustly computes regionsof collision and self-collision on garments. We also solvedthe problems arising due to aliasing and degenerateprojections that may occur in the image-space.

The advantage of this method is that we can handleirregular regions. We do not need to maintain an adjacentmatrix among the subsurfaces. The surface is partitionedinto a set of ð�; �Þ-surfaces. We render these subsurfaces intothe frame buffer. The rough distance information among thetriangles of the cloth is stored in the frame buffer. Instead ofperforming collision detection by using the frame bufferinformation directly, we collect the potential collidingtriangle pairs for further processing. Moreover, a methodis developed to alleviate the problems induced by aliasingdue to the frame buffer sampling. A dynamic backwardvoxel-based method (BVOX) is proposed to construct theAxis-Aligned Bounding Box (AABB) trees for the subsur-faces in order to perform collision detection among them.

2 (�, �)-SURFACE

In order to define the class of ð�; �Þ-surface, we consider

a polygonal surface S which consists of a set of

triangles T ¼ fti; i ¼ 1 . . .ng. The normal of a triangle

ti is a unit vector ni. We define a polygonal surface to

be (�, �) if there exists a unit vector �s and an angle �ssuch that, for all i 2 f1; 2; � � � ; ng, we have �s � ni � cos�s,

where 0 � �s < �=2. We call this surface the ð�s; �sÞ-surface,where �s is the surface direction and �s is the surface angle.

We assume that there are no narrow triangles.

3 (�, �)-SURFACE PARTITIONING

A constant hierarchy [51] fails to adapt to the shape of thecloth. If a single triangle doe not satisfied the low curvaturecondition, two subsurfaces cannot be merged. To partition asurface into a set of ð�; �Þ-surfaces dynamically each frame,we extend the work of Provot [41]. We want to grow eachð�; �Þ-surface as large as possible. In our algorithm, thegrowth of the surface angle is slower than the one proposedin Provot’s method.

A single triangle is, by definition, a ð�; �Þ-surface. Thesurface direction is the normal of the triangle and the surfaceangle is zero. To partition a surface into ð�; �Þ-surfaces, westart with a single triangle and add its edge-shared trianglesinto a queue. At each step, we pick a triangle from thequeue and check whether we can merge this triangle intothe current ð�; �Þ-surface. If we can, then we update thesurface direction and the surface angle. Moreover, the edge-shared triangles are added to the queue if they do notbelong to any ð�; �Þ-surfaces. If we cannot grow theð�; �Þ-surface anymore, we construct another ð�; �Þ-surfaceby picking another triangle not belonging to a ð�; �Þ-surfaceand repeat the entire process. By doing so, we partition thesurface into a set of ð�; �Þ-surfaces. We use a queue becausewe want to merge the nearest triangles first.

The merging process is implemented as follows: Con-sider two surfaces (�0, �0) and (�1, �1), Fig. 1. Let � be the

angle between �0 and �1. If (�0 þ �1 þ � < 2�max), then thesetwo surfaces can be merged into a larger surface with the

new surface direction �s and surface angle �s, where�s ¼ ð�0

0 þ �01Þ=k�0

0 þ �01k, and �s ¼ ð� þ �0 þ �1Þ=2, ([42]).

�max is used to control the quality of the resultant surface

and its value is in the interval ½0; �=2Þ.

4 SELF-COLLISION DETECTION

For a finite set of tests that can be supported by hardware,we must assume that, for any straight line along the surfacedirection, the line intersects a ð�; �Þ-surface at most twopoints. By projecting a plane along its normal, we willmaximize its image area. It is likely that, by projecting thesubsurfaces along their � direction, we will maximize theirimage area. Therefore, the subsurfaces are orthogonallyprojected onto a viewport along � (projection direction)when they are rendered. We also compute a projectionorientation about the projection direction in order tomaximize the area occupied by the surface with respect tothe viewport dimension. The ideal projection orientation isaligned with the viewport perpendicular to the tightoriented bounding box (OBB) of the surface image.However, this is more computationally intensive. Weapproximate this projection orientation by computing an

650 IEEE TRANSACTIONS ON VISUALIZATION AND COMPUTER GRAPHICS, VOL. 10, NO. 6, NOVEMBER/DECEMBER 2004

Fig. 1. Merging two surfaces ð�; �Þ-surfaces, ð�0; �0Þ and ð�1; �1Þ.

orientation such that the AABB image of the local AABB ofthe surface aligns with the viewport.

Each triangle is assigned a unique positive integer. Whenthe triangle is rendered, this integer is converted to a color(Red, Green, Blue).1 We reserve the integer zero as thebackground color. After the surface is rendered, we retrievethe contents of the frame buffer into the main memory andscan the buffer.

4.1 Frame Buffer Scanning

We assume that the frame buffer stores the pixel color of theincoming fragments that have the smallest depth value.Two triangles are adjacent if and only if they share a vertex.Otherwise, two triangles are nonadjacent. We assume that,for a ð�; �Þ-surface, a triangular mesh intersects itself if twononadjacent triangles intersect. However, this assumption isnot applied to the boundary triangles. During the AABBtree traversal, the collision of adjacent interior triangles isautomatically prevented by checking the nonadjacenttriangles [33]. We should point out that, in some specialcases, three interior adjacent triangles may collide if thesurface continuity conditions are violated by decimation,for example, a triangular mesh in which a T-vertex iscreated by cutting along one of the edges at the T-vertex andtwo additional triangles are attached to the vertex. Thismesh is initially a valid ð�; �Þ-surface. Through internalmotion, the three interior triangles may theoretically collide.However, this anomaly is caused by the introduction of aT-vertex in the mesh representation of the surface. Inpractice, this is not likely to occur.

There are three possible cases resulting from theintersection of two triangles: 1) a point, 2) a line, or 3) aplane. We assume that, when two triangles are rendered,they occupy at least one pixel in the frame buffer. However,we may not be able to guarantee that each triangle occupiesat least one pixel. This occurs if one of the followingconditions arises:

1. A triangle is coplanar with a larger triangle and theformer triangle may lie entirely inside the latter (aplane intersection region). After rendering, we donot know whether the fragments of the former oneor the latter one will be stored in the frame buffer. Itis possible that only the fragments of the secondtriangle are stored. The first one is missed.

2. One of the two triangles just touches the other andthe former triangle is entirely lying behind the latter(a point-line intersection region).

3. The triangle is either too narrow or too small tooccupy a pixel (subsampling).

In order to solve these problems, we render the missingtriangles at the same resolution again. We also use theadjacent information (see Section 4.2) to construct thepotential colliding pairs for the missing triangles.

After the surface is rendered, we read the contents of theframe buffer of each viewport and store them into a two-dimensional array. For each pair of adjacent pixels,2 weinspect the pixel color indices. If the corresponding

triangles of the color indices do not share a vertex, thetriangles may collide. We store all these potential collidingpairs and perform intrinsic triangle tests for the pairs ([37]).(It is possible to perform the triangle collision detection intime domain ([9], [32]) as well.)

4.2 Dynamic Viewport

The area of the projected image of a triangle changes whenthe orientation of the triangle changes with respect to theprojection direction. We want the viewport to be largeenough so that each triangle will occupy at least a singlepixel while the viewport cannot be too large or this will takelonger time to scan the frame buffer. We develop a methodto compute the dimension of the viewport dynamically for adifferent surface angle as follows:

Consider an equilateral triangle4ABC, Fig. 2. Let ‘ be thelength of a side of the triangle,D themiddle point ofAB, andB0 the image ofB.Wewant to computeDB0 when the trianglerotates about the axis alongAC. Assume ffBDB0 ¼ �s. Underthis setup, we obtain DB0 ¼

ffiffiffiffiffiffiffiffi3=4

p‘cos�s. If we project DB0

further onto the x and y axes, respectively, we obtain theminimum longest length of its image


p‘cos�s. Before

the simulation, we compute ‘ as the average of the shortestedges of the triangles. The rotation angle is simply thesurface angle. So, we have ‘0 ¼


p‘cos�s. We define

AABB0 as the image of the AABB on the viewport after theAABB is aligned with the viewport axes. Assume that thedimension of AABB0 (defined in Section 4) of the surface isðbx; byÞ. Then, the dimension of the viewport is ðbx=‘0; by=‘0Þ.We may also scale up or down the dimension of theviewport. If we scale up it, we will spend a much longertime scanning the frame buffer. If we scale down it, we willhave many more missing triangles.

Sometimes, there are triangles not occupying a singlepixel when the ð�; �Þ-surface is rendered. We call thesetriangles “missing triangles.” In order to solve this problem,we propose using the information of their adjacent trianglesto construct their potential colliding pairs. This is justifiedas follows: Consider a triangle which does not occupy asingle pixel. Then, its image should be covered by theimages of its adjacent triangles. We assume that the pixelsof its adjacent triangles belonged to it. In this way, wecollect the potential colliding pairs involving it.

4.3 Multiviewport Rendering

We construct dynamic viewports for rendering theð�; �Þ-surfaces. Our goal is to render not just a singleð�; �Þ-surface at a time but as many ð�; �Þ-surfaces aspossible, Fig. 3. We arrange the viewports of theð�; �Þ-surfaces in the rendering window in a nonoverlappingmanner. We repeat this process until no more viewports canbe placed. This completes one assignment process. Werender the corresponding ð�; �Þ-surfaces and perform theframe buffer scanning. The same procedure is applied for

BACIU AND WONG: IMAGE-BASED COLLISION DETECTION FOR DEFORMABLE CLOTH MODELS 651

Fig. 2. Selecting the viewport dimension.

1. A similar idea is used in [28], [8].2. Two pixels are adjacent if the distance between them is equal to one.

The distance metric is dððx1; y1Þ; ðx2; y2ÞÞ ¼ maxðj x1 � x2 j; j y1 � y2 jÞ,where ðx1; y1Þ and ðx2; y2Þ are the coordinates of two pixels.

the remaining ð�; �Þ-surfaces. The details of the assignmentprocess are discussed next.

4.4 Multiviewport Assignment

Given a set of small rectangles (viewports), denoted byRs ¼ fr1; r2; � � � ; rng and a large rectangle R (renderingwindow) in 2D integer domain. Each small rectangle ri haswidth wi and hi. Let the large rectangle R have width Rw

and height Rh such that Rw � wi, Rh � hi, for all smallrectangles ri. All variables wi, hi, Rw, Rh � 1, i.e., at leastpixel size. The task is to assign the small rectangles into Rsuch that two constraints must be satisfied: 1) The smallrectangles should lie entirely inside R, 2) the smallrectangles should not overlap one another. During theassignment, we only translate the small rectangles withoutrotation. We do not need to put all the small rectangles intoR at the same time. If no more small rectangles can beadded, we restart all over with the remaining smallrectangles. This is a 2D rectangle packing problem, whichis known as an NP-hard problem. The more generalpacking problem is discussed in [7], [25]. We are notinterested in the optimal solution. We want to have analgorithm which arranges the small rectangles as fast aspossible and reasonably tightly.

We define an integer Cartesian Coordinate System withrespect to the large rectangle. The origin is the lower leftcorner of the large rectangle. We define the x axis along thehorizontal direction and the y axis along the verticaldirection.

During the assignment of the small rectangles, wemaintain a data structure called the shifted envelope. Theenvelope helps us quickly locate a position to place thesmall rectangles. The data structure of the envelope has twointeger arrays, W and H, both of size Rw þ 1. The array Wstores the relative position of the next height change alongthe x axis, with respect to the current position in thex-coordinate. The array H stores the height of the envelope(the maximum y-coordinates of small rectangles) along thex axis. The initial envelope is a straight line segmentstarting from the origin of the x-coordinate 0, length of Rw,and height of zero, i.e., ðW0; H0Þ ¼ ðRw; 0Þ.

To place a small rectangle riðwi; hiÞ into the largerectangle, we start from the position ð0; H0Þ 3 and thenadjust the y-coordinate when necessary. This is done by

adding a nonnegative offset � to the y-coordinate. So, � isthe minimum value such that, when we place the rectangleat ð0; H0 þ �Þ, the two constraints are satisfied, Fig. 5.Assume that we are at the x-coordinate x. We must checkwhether we can place the small rectangle at ðx;Hx þ �Þ. Ifwe can, then the small rectangle should lie entirely insidethe large rectangle and these two conditions are satisfied:Rw � xþ wi and Rh � Hx þ hi þ �.

We defineXðx;wiÞ such that it contains the x-coordinatesof all the positions that are needed to check for the smallrectangle, starting from the coordinate x.

Xðx;wiÞ � x0n < minfxþ wi;Rwg j

�x0n ¼ x0

n�1 þWx0n�1

; n � 1 or x0n ¼ x; n ¼ 0

o:

ð1Þ

Obviously, x should satisfy the condition: x 2 Xð0; RwÞ.In order to impose the nonoverlapping restriction of theplacement of the small rectangles in an incremental manner,we have

8x0 2 Xðx;wiÞ Hx þ � � Hx0 : ð2Þ

This condition ensures that the small rectangle riðwi; hiÞdoes not overlap with the portion behind the envelope. Ifwe fail to place the small rectangle at ðx;Hx þ �Þ for any �,we advance Wx

4 units along the x axis and check the nextposition ðWx þ x;HWxþxÞ. We repeat the procedure until weeither find a position to place the small rectangle or run outof the array W . We update the boundary of the envelope ifwe find a position for the small rectangle. An example isshown in Fig. 4. The assignment of the small rectangles isterminated if we run out of the array W .

If we place the small rectangle at a position where thereis an immediate unfilled space, we have fragmentation orwasted space under the small rectangle. In Fig. 4, s4 showsthe fragmented space in the viewport by the placement ofthe small rectangle r4. We compute a position to place asmall rectangle such that the fragmented space si is thesmallest.

5 COLLISION DETECTION AMONG (�, �)-SURFACES

In order to construct the Bounding Volume Tree (BVT) foreach ð�; �Þ-surface, we employ a backward voxel-based


Fig. 3. Arrangement of the dynamic multiviewport as the cloth deforms. (The colors in the viewports are inverted.)

3. The value Hx is the integer which is stored at the xth position of thearray H.

4. The value Wx is the integer which is stored at the xth position of thearray W .

approach. After the BVT is constructed, we perform the tree

traversal to collect the potential colliding triangle pairs for

each pair of ð�; �Þ-surfaces.

5.1 Voxel-Based: Construction of BVT Tree

Let the dimension of the AABB of the entire surface be

bx; by; bzÞ. We name this AABB as AABB0 (i.e., the root

of the BVT, at depth zero). Let the reference point of

AABB0 be ðxmin; ymin; zminÞ such that, for any vertex

ðx; y; zÞ, we have x 2 ½xmin; xmin þ bx�, y 2 ½ymin; ymin þ by�,and z 2 ½zmin; zmin þ bz�. i.e., AABB0 enclosing all the

triangles of the surface. We take into account the thickness

of the cloth. Without loss of generality, we assume that

bx � by � bz.In the forward approach, we recursively partition the

cloth along the medial axis of the longest side of AABB0

into voxels, assign the triangles to them, group them, and

form nodes until a desired subdivision level (depth) is

reached. Finally, with respect to AABB0, the number of

subdivision levels along the x, y, and z axes, respectively,

will be nx, ny, and nz. Thus, along the x, y, and z axes,

AABB0 is cut evenly into 2nx , 2ny , and 2ny pieces,

respectively. As we assume that bx � by � bz, we will have

nx � ny � nz � 0.In the backward voxel-based approach, we compute nx,

ny, and nz directly for a given depth d and the triplet

ðbx; by; bzÞ. We compute nx, ny, and nz such that they are as

close as possible to the ones obtained from the forward

method. They are computed as follows:

nx ¼ dny ¼ nz ¼ 0

�if bx � 2d�1by ð3Þ

nx ¼ min log2bxbyþ dþ 1

� �=2

j k; d

n ony ¼ d� nx

nz ¼ 0

9>>=>>;

if bx < 2d�1by andby

2ny�1� bz

ð4Þ

nx ¼ min log2b2xbybz

þ dþ 2� �

=3j k

; dn o

ny ¼ min log2b2ybxbz

þ dþ 2� �

=3j k

; dn o

nz ¼ maxfd� nx � ny; 0g

9>>=>>;Otherwise: ð5Þ

To build the tree bottom-up, we recursively assign nodes

to voxels, form new nodes, and get to the next level up until

we are left with one voxel, i.e., AABB0, which is the root

node. We call this tree the BVOX-AABB (backward voxel-

based AABB) tree. Nodes at the leaf level are AABBs of the

triangles. These AABBs enclose the triangles at the begin-

ning and final positions within a frame and they are

enlarged by the thickness of the cloth. The nodes at the

same voxel form a new node and the AABB of the new node

is computed. The assignment of a node to a voxel ði; j; kÞ isdetermined by using equations:

i ¼ minx� xmin

bx

� �2nx

� ; 2nx � 1

�;

j ¼ miny� ymin

by

� �2ny

� ; 2ny � 1

�; and

k ¼ minz� zmin

bz

� �2nz

� ; 2nz � 1

�;


Fig. 4. An assignment sequence of four small rectangles, r1ð3; 3Þ, r2ð3; 5Þ, r3ð2; 4Þ, and r4ð5; 4Þ, into a large rectangle Rð12; 8Þ. In (a),Xð0; 12Þ ¼ f0; 3; 12g. In (b), Xð0; 12Þ ¼ f0; 3; 6; 12g. In (c), Xð0; 12Þ ¼ f0; 3; 6; 10; 12g. In (d), Xð0; 12Þ ¼ f0; 3; 6; 11; 12g. The fragmented space s4 of r4is equal to 2.

Fig. 5. Probing positions for the small rectangle r4ð4; 5Þ in Rð12; 8Þ.Xð0; 5Þ ¼ f0; 3; 6; 12g. In (a), we try to place r4 at ð0; 3Þ at the beginning. During the

validation process, � is adjusted to 2, i.e., trying to place it at (0, 3+2), but a part of it lies outside R. In (b), we try to place it at ð3; 5Þ but this is invalid.

In (c), placing it at ð6; 2Þ is possible.

where ðx; y; zÞ is the center point coordinate of the AABB of

the node. The depth dmax of the tree is dmax ¼ dlognte,where nt is the total number of triangles of the surface.

6 EXPERIMENTS AND RESULTS

In our implementation, we render the objects into the pixel

buffer (pbuffer). The advantage of using the pbuffer is that

we can perform offscreen rendering ([1]). All the experi-

ments were run on a 1.5GHz Pentium 4 PC with 1GB of

main memory and an nVidia geForce 3 graphics card.We built a model of a partially cut cloth as in Fig. 6 in

order to demonstrate the interactions due to self-collision

and the collision of the cut cloth with other objects. This also

serves as a good example for taking performance statistics

of our collision detection algorithm. The performance

statistics for this example are shown in Fig. 7 for �max ¼60 deg: and �max ¼ 70 deg. By selecting different �max angles

for controlling the smoothness condition in dynamically

clustering the ð�; �Þ-surfaces, we show that the timing

characteristics for the collision detection as the number of

triangular elements increase from 134 to 52,840 have similar

growth rates.The graphs in Figs. 7a and 7c show the scene rendering

and the collision detection times for surface clusters that

maintain a threshold of �max � 60 deg: and �max � 70 deg.

As the number of triangles increases, the time patterns for

the collision detection are similar in all cases ranging from

under 30ms for low triangle counts of about 1,000 to around

one second for triangle counts in excess of 50,000. In all


Fig. 6. Example: Draping of a single cut cloth on three sphere-like tables.

Fig. 7. Partially cut cloth. � ¼ 60 deg and � ¼ 70 deg.

cases, the rendering times are lower than the collisiondetection times. However, we must emphasize again thatthe image-space collision computation is emulated insoftware using the data extracted from the frame buffer.This contributes to IO transfers and main memory checks.The multiviewport setup algorithm is also software emula-tion which contributes to the collision detection time. Ifthese operations are supported in hardware, we expect theimage-space computations to be drastically reduced.

The interesting feature of this algorithm is the impact ofthe threshold angle �max on the distribution and computa-tional loads for the object-space and image-space, respec-tively. We note that the distribution of computations acrossthe object-space and the image-space shifts toward theobject-space by approximately 10 percent, Figs. 7b and 7d.This means that, as �max increases, the image-space loadalso increases and the object-space load decreases. The mainreason is that, as �max increases, the viewport sizes alsoincrease, making the image-space the dominant computa-tional load for collision detection. This result is positive ontwo accounts. First, as �max increases, the relative curvatureof the surface patch is allowed to vary more than for lower�max values. Thus, the bounding volume tree decreases insize as large regions can be accommodated. Second, theload is taken up by the image-space tests that can be furtheroptimized by hardware support or parallelizing the process.

In the following, we performed the comparisons amongthree methods: 1) image-based method, 2) BVOX-AABBtree, and 3) AABB tree. We implemented the AABB tree,which was proposed in [33], [48]. We stored the nodes in alinear array so that we could update the tree withouttraversing it. We set �max ¼ 60 deg. We constructed fourscenes in which the complexity of the cloth could beadjusted (see snapshots in Fig. 8). Usually, the performanceof the methods depends on the configuration of the scenes.Therefore, we tracked their performance for the entireanimation sequence in the four scenes. We plotted thefollowing graphs:

a. total collision detection time in each frame,b. detailed profile of the image-based method,c. number of ð�; �Þ-surfaces (PIBs) and percentage of

missing triangles,d. BVT (bounding volume tree) traversal time,e. BVT update time,f. number of bounding box tests, andg. the number of potential colliding triangle pairs.

We define the potential colliding triangle pairs (PCPs) asthe pairs which will be tested using the intrinsic trianglecollision detection.

In scene one, a rectangular piece of cloth (44,688 tri.),which has short fringes at two boundaries, falls on a scepter(1,600 tri.) with a long leg sticking up on the ground. Whenthe cloth drapes on the scepter, the sides are pulled backtogether and wrinkles arise. At the beginning, the image-based method is almost four times faster than the AABBand the BVOX-AABB methods, Fig. 9. At the end, when thecloth deforms drastically, the image-based method becomesslower. The BVOX-AABB turns out to be the fastest at theend of the animation. The ranges of the collision detectiontime of the image-based, the BVOX-AABB, and the AABB

methods are 0.4-0.7 (sec), 0.45-1.85 (sec), and 0.65-1.85 (sec),respectively.

In scene two, a cylindrical piece of cloth (45,600 tri.) fallson a hemisphere (1,600 tri.) and then onto the ground. Theupper part of the cloth is cut into three rectangular pieces.During the animation, the cloth collides with the hemi-sphere and is compressed itself along the axial direction.When the cloth is compressed, there are a lot of self-collisions. At the beginning, the image-based method is thefastest, Fig. 10. As the cloth is compressed, the image-basedmethod becomes slower. The BVOX-AABB method hasstable performance in this case. The ranges of the collisiondetection time of the image-based, the BVOX-AABB, andthe AABB methods are 0.35-2.7 (sec), 0.9-1.3 (sec), and 0.9-2.3 (sec), respectively.

In scene three, a rectangular piece of cloth (46,524 tri.)with a long fringe in the middle falls on the other part. Tworows of the middle vertices are fixed during the animation.In this experiment, we do not have complex wrinklepatterns. However, it shows clearly how the long fringecollides with another part of the cloth. It demonstrates thatthe proposed image-based method can handle the irregularshape of the cloth. As the cloth does not deform much, theimage-based method performs stably, Fig. 11. The image-based method is the fastest during the entire animation. Theranges of the collision detection time of the image-based,the BVOX-AABB, and the AABB methods are 0.35-0.5 (sec),0.5-1.75 (sec), and 0.6-1.9 (sec), respectively.

In scene four, a “net” (45,056 tri.) falls on a scepter(1,600 tri.) at the beginning of the animation. The net is arectangular piece of cloth with regular holes. At frame 400,the scepter is removed. After that, the net continues to fallonto the ground (800 tri.). At the beginning, the collisiondetection time of the image-based, the BVOX-AABB, andthe AABB methods, are 0.45, 1.75, and 1.9 (sec), respec-tively, Fig. 12. At the end, the collision detection times of theimage-based, the BVOX-AABB, and the AABB methods are0.8, 0.45, and 0.8 (sec), respectively. The ranges of thecollision detection time of the image-based, the BVOX-AABB, and the AABB methods are 0.45-0.8 (sec), 0.4-1.75 (sec), and 0.6-1.9 (sec), respectively.

When the cloth does not deform much, the AABB andthe BVOX-AABB methods spend a lot of time in thetraversal (see graphs (d) and (f)). For the image-basedmethod, it is suitable to handle deformable surfaces whichhave large “low curvature” regions. When the cloth is quiteflat, there are a lot of AABBs overlapping. Most of thecorresponding triangles do not collide. The image-basedmethod successfully skips these noncolliding triangle pairs(see graphs (g)) as they are far away. When the clothdeforms drastically, the cloth surface is partitioned into a lotof small ð�; �Þ-surfaces (graphs (c)) for collision detection.This will take a longer time to scan the frame buffer as wellas to construct the BVTs. To perform collision detection forthese subsurfaces, we need to perform BVT traversal for allpairs of the subsurfaces. This increases the time signifi-cantly. However, the BVOX-AABB method performs quitestably in this situation.

When we render the ð�; �Þ-surfaces into the frame buffer,we may have some “missing” triangles which do not have apixel in the frame buffer. However, the percentage of themissing triangles is relatively low. The percentages are


0-6 percent, 0-8 percent, 0-3.5 percent, and 0-0.4 percent inscenes one, two, three, and four, respectively.

In graphs (b), the time spent in four essential compo-nents in the image-based method is shown:

1. partitioning the cloth surfaces into ð�; �Þ-surfaces,2. rendering the ð�; �Þ-surfaces,3. reading the frame buffer (FB) into the main memory,

and4. scanning the frame buffer.

The process of scanning the frame buffer takes more than50 percent of the time. The partitioning process is thesecond highest (except in scene two)).

The BVOX-AABB tree outperforms the constant hier-

archy AABB tree. It takes about twice the time to update a

BVOX-ABB tree as to update a AABB tree (see graphs (e)).

However, the traversal time spent in BVOX-AABB is much

faster than the constant AABB tree (see graphs (d)). It takes

a smallerr number of bounding box tests in the BVOX-

AABB tree than the constant AABB tree (see graphs (f)).

(The traversal time is proportional to the number of

bounding box tests.) When the cloth deforms drastically,

the traversal speedup is around three.


Fig. 8. Snapshots of the four scenes.

Finally, we changed the complexity of the cloth andcollected the statistics. We have similar graph patterns in allcases. In Fig. 13, we show the average total collision detection(CD) time of the animation. For scenes one, three, and four,

the imaged-based method is the fastest. For scene two, theBVOX-AABBmethod is the fastest. The average total CD timeis proportional to the number of triangles of the cloth. In allcases, the method of the constant AABB tree is the slowest.


Fig. 9. Performance profiles of the three methods for scene 1.

7 CONCLUSIONS AND FUTURE WORK

We proposed a hardware-assisted method for performingefficient collision detection by 1) utilizing object-spacepartitioning and culling of large surfaces into ð�; �Þ-surfaces

and 2) performing triangle image space for arbitrary

deformable surfaces.We acquire the image-space information using the

multiple dynamically adjustable viewports that represent



the projections of overlapping regions of a surface in the

object space. We perform a scanning process to collect all

the potential colliding triangle pairs by using the

image-space information. After that, we perform the final

collision tests for the triangle pairs in the object space.



The robustness of this collision detection method is

ensured by 1) automatic segmentation of a general surface

into ð�; �Þ-surface patches. This guarantees local convexity

as a basic requirement for hardware-based collision tests,

2) aliasing detection and subpixel sampling together with

tracking the influence of all the neighboring pixels of the

current pixel in the image-space. This takes into account the



active tracking of the source triangles in the image buffers,as described in Section 4.1.

The image-space loading increases with the increase ofthe threshold angle �max as the viewport size becomes thedominant bottleneck in the computational process. A goodbalance between the threshold angle, viewport processing,and the boundary volume tree is the key to an efficient androbust collision detection algorithm that makes use of theimage buffers. However, this also depends on the hardwaresupport for reading, writing, and scanning the imagebuffers efficiently. Currently, the scanning process of theimage buffers is emulated in software. In the future, webelieve that, if the scanning process can be entirely done inhardware, a significant improvement in the collisiondetection speed can be achieved.

The proposed BVOX-AABB method is suitable forcollision detection if the cloth is highly compressed. Itautomatically allocates the neighboring triangles in thesame branches of the tree. Thus, it significantly reduces thetraversal time comparing to the constant AABB treestructure.

Some further extensions of this work under investigationare the following:

1. Direct extraction of subsurfaces. Currently, a surface ispartitioned into a set of ð�; �Þ-surfaces at each frame.This step is done in the object space. Another

approach is to use the image information to partitionthe surface. For example, we can render the surfaceand then collect all the triangles which contribute atleast one pixel in the frame buffer. Then, the surfacecan be partitioned into two subsurfaces consisting of:a) a set of triangles that appear in the frame bufferand b) a set of triangles that do not appear in theframe buffer. We can repeat this subdivision withthe triangles that do not appear in the frame buffer.This approach may create a smaller number ofsubsurfaces. Moreover, if multiframe buffers aresupported, the number of required renderings canbe dramatically reduced.

2. Time-domain extensions for collision detection. Ourcurrent approach is based on robust static inter-ference tests for the potential colliding triangles. Thestatic interference test by itself is fast and requiresless computational overhead. The distance informa-tion between triangles is stored in the frame buffer.If the relative movement of the cloth is small, ourcurrent method can be extended to handle collisiondetection in time domain directly by simply repla-cing the intrinsic triangle test unit. However, due topotential undersampling, collision events may bemissed as a triangle could potentially pass throughanother completely in a single frame. No matter how


Fig. 13. Average collision detection time for varying cloth surface complexity. (a) Scene one: A piece of cloth with short fringes falls on a scepter with

a long leg. (b) Scene two: A piece of cloth in a cylindrical configuration falls on a hemisphere. (c) Scene three: A piece of cloth with a single long

fringe in the middle falls on itself. (d) Scene four: A net falls on a scepter with a long leg and then onto the ground.

small the time step, such collision events may bedifficult to detect. The method described in thispaper can be extended to take into consideration therelative motion of the triangles and establish anintermediate checkpoint based on the relativevelocities of the vertices of the triangles. This iscurrently under investigation with positive preli-minary results. However, this also leads to addi-tional computational overhead that can substantiallyadd to the static collision test.

ACKNOWLEDGMENTS

This research was supported by HK RGC CERG grant B-

Q566 and internal grant 4-ZD4U.

REFERENCES

[1] “Using P-Buffers for Off-Screen Rendering in OpenGL,” http://developer.nvidia.com/docs/IO/1312/ATT/PixelBuffers.pdf,2003.

[2] G. Baciu and W.S.K. Wong, “Hardware-Assisted Self-Collision forDeformable Surfaces,” Proc. ACM Symp. Virtual Reality Softwareand Technology, pp. 129-136, Nov. 2002.

[3] G. Baciu and W.S.K. Wong, “Image-Based Techniques in a HybridCollision Detector,” IEEE Trans. Visualization and ComputerGraphics, vol. 9, no. 2, pp. 254-271, Apr.-June 2003.

[4] G. Baciu, W.S.K. Wong, and H. Sun, “RECODE: An Image-BasedCollision Detection Algorithm,” J. Visualization and ComputerAnimation, vol. 10, no. 4, pp. 181-192, 1999.

[5] G. Banel, “Cloth Simulation: From the Movie Final Fantasy, TheSpirits Within to the Game,” Proc. Game Developers Conf.(GDC2002), Mar. 2002.

[6] D. Baraff and A. Witkin, “Large Steps in Cloth Simulation,”Computer Graphics (Proc. SIGGRAPH ’98), pp. 43-54, 1999.

[7] P. Berman, B. Dasgupta, S. Muthukrishnan, and S. Ramaswami,“Improved Approximation Algorithms for Rectangle Tiling andPacking,” Proc. Symp. Discrete Algorithms, pp. 427-436, 2001.

[8] M. Botsch and L.P. Kobbelt, “A Robust Procedure to EliminateDegenerate Faces from Triangle Meshes,” Proc. Vision Modelingand Visualization Conf., pp. 283-290, 2001.

[9] R. Bridson, R. Fedkiw, and J. Anderson, “Robust Treatment ofCollisions, Contact and Friction for Cloth Animation,” ACM Trans.Graphics, vol. 21, no. 3, pp. 594-603, 2002.

[10] S.F. Chen, J.L. Hu, and J.G. Teng, “A Finite-Volume Method forContact Drape Simulation of Woven Fabrics and Garments,” FiniteElements in Analysis and Design, vol. 37, pp. 513-531, 2001.

[11] K. Chung and W. Wang, “Quick Collision Detection of Polytopesin Virtual Environments,” Proc. ACM Symp. Virtual RealitySoftware and Technology, pp. 125-132, July 1996.

[12] J. Cohen, M.C. Lin, D. Manocha, and M. Ponamgi, “I-COLLIDE:An Interactive and Exact Collision Detection System for Large-Scale Environments,” Proc. ACM Interactive 3D Graphics Conf.,pp. 189-196, 1995.

[13] F. Cordier, P. Volino, and N. Magnenat-Thalmann, “IntegratingDeformations between Bodies and Clothes,” J. Visualization andComputer Animation, vol. 12, no. 1, pp. 45-53, Feb. 2001.

[14] S. Fisher and M.C. Lin, “Deformed Distance Fields for Simulationof Non-Penetrating Flexible Bodies,” Computer Animation andSimulation: Proc. Eurographics Workshop Computer Animation andSimulation, D. Thalmann, J.F. Canny, N. Magnenat-Thalmann,eds., pp. 99-112, 2001.

[15] A. Garcia-Alonso, N. Serrano, and J. Flaquer, “Solving theCollision Detection Problem,” IEEE Computer Graphics andApplications, vol. 13, no. 3, pp. 36-43, 1994,

[16] E.G. Gilbert, D.W. Johnson, and S.S. Keerthi, “A Fast Procedurefor Computing the Distance between Objects in Three-Dimen-sional Space,” J. Robotics and Automation, vol. 4, no. 2, pp. 193-203,1988.

[17] S. Gottschalk, “Separating Axis Theorem,” Technical Report TR96-024, Dept. of Computer Science, Univ. of North Carolina ChapelHill, 1996.

[18] S. Gottschalk, M.C. Lin, and D. Manocha, “OBBTree: A Hier-archical Structure for Rapid Interference Detection,” ComputerGraphics (Proc. SIGGRAPH ’96), pp. 171-180, Aug. 1996.

[19] M. Held, J.T. Klosowski, and J.S.B. Mitchell, “Evaluation ofCollision Detection Methods for Virtual Reality Fly-Throughs,”Proc. Canadian Conf. Computational Geometry, pp. 205-210, 1995.

[20] B.V. Herzen, A.H. Barr, and H.R. Zats, “Geometric Collision forTime-Dependent Parametric Surfaces,” Computer Graphics (SIG-GRAPH ’90), vol. 24, no. 4, pp. 39-48, 1990.

[21] J. Hu and Y.F. Chan, “Effect of Fabric Mechanical Properties onDrape,” Textile Research J., vol. 68, no. 1, pp. 57-64, 1998.

[22] P.M. Hubbard, “Collision Detection for Interactive GraphicsApplications,” EEE Trans. Visualization and Computer Graphics,vol. 1, no. 3, pp. 218-228, Sept. 1995.

[23] P.M. Hubbard, “Approximating Polyhedra with Spheres for Time-Critical Collision Detection,” ACM Trans. Graphics, vol. 15, no. 3,pp. 179-210, 1996.

[24] K.E. Hoff III, A. Zaferakis, M.C. Lin, and D. Manocha, “Fast andSimple 2D Geometric Proximity Queries Using Graphics Hard-ware,” Proc. 2001 Symp. Interactive 3D Graphics, pp. 145-148, 2001.

[25] S. Khanna, S. Muthukrishnan, and M. Paterson, “On Approximat-ing Rectangle Tiling and Packing,” Proc. Ninth Ann. ACM-SIAMSymp. Discrete Algorithms (SODA ’98), pp. 384-393, 1998.

[26] Y.J. Kim, M.A. Otaduy, M.C. Lin, and D. Manocha, “FastPenetration Depth Computation for Physically-Based Animation,”Computer Graphics (Proc. ACM SIGGRAPH 2002), pp. 23-31, 2002.

[27] J.T. Klosowski, M. Held, S.B.J. Mitchell, H. Sowizral, and K. Zikan,“Efficient Collision Detection Using Bounding Volume Hierar-chies of k-DOPs,” IEEE Trans. Visualization and Computer Graphics,vol. 4, no. 1, pp. 21-36, Jan. 1998.

[28] L.P. Kobbelt and M. Botsch, “An Interactive Approach to PointCloud Triangulation,” Computer Graphics Forum, vol. 19, no. 3,pp. 479-487, 2000.

[29] M.C. Lin and J.F. Canny, “Efficient Collision Detection forAnimation,” Proc. Third Eurographics Workshop Animation andSimulation, Sept. 1992.

[30] M.C. Lin and S. Gottschalk, “Collision Detection betweenGeometric Models: A Survey,” Proc. IMA Conf. Math. of Surfaces,1999.

[31] M.C. Lin and D. Manocha, “Fast Interference Detection betweenGeometric Models,” The Visual Computer, vol. 11, no. 10, pp. 542-591, 1995.

[32] J.D. Liu, M.T. Ko, and R.C. Chang, “Collision Avoidance in ClothAnimation,” The Visual Computer, vol. 12, no. 5, pp. 234-243, 1996.

[33] J.D. Liu, M.T. Ko, and R.C. Chang, “A Simple Self-CollisionAvoidance for Cloth Animation,” Computers and Graphics, vol. 22,no. 1, pp. 117-128, 1998.

[34] S. Melax, “BSP Collision Detection as Used in MDK2 andNeverWinter Nights,” Proc. Game Developers Conf. (GDC2001),Mar. 2001.

[35] D. Metaxas and D. Terzopoulos, “Dynamic Deformation of SolidPrimitives with Constraints,” Computer Graphics (Proc. SIGGRAPH’92), vol. 26, no. 2, pp. 309-311, July 1992.

[36] B. Mirtich, “V-Clip: Fast and Robust Polyhedral CollisionDetection,” ACM Trans. Computer Graphics, vol. 17, no. 3, pp. 177-208, July 1998.

[37] T. Moler, “A Fast Triangle-Triangle Intersection Test,” J. GraphicsTools, vol. 2, no. 2, pp. 25-30, 1997.

[38] M. Moore and J.P. Wilhelms, “Collision Detection and Responsefor Computer Animation,” Computer Graphics (Proc. SIGGRAPH’88), vol. 22, pp. 289-298, 1988.

[39] M. Ponamgi, D. Manocha, and M.C. Lin, “Incremental Algorithmsfor Collision Detection between General Solid Models,” Proc.ACM/SIGGRAPH Symp. Solid Modeling, pp. 293-304, 1995.

[40] M.K. Ponamgi, D. Manocha, and M.C. Lin, “Incremental Algo-rithms for Collision Detection between Polygonal Models,” IEEETrans. Visualization and Computer Graphics, vol. 3, no. 1, pp. 51-64,Jan.-Mar. 1997.

[41] X. Provot, “Collision and Self-Collision Handling in Cloth ModelDedicated to Design Harments,” Proc. Computer Animation andSimulation ’97, pp. 177-189, 1997.

[42] T.W. Sederberg and R.J. Meyers, “Loop Detection in Surface PatchIntersections,” Computer Aided Geometric Design, vol. 5, no. 2,pp. 161-171, 1988.


[43] A. Smith, Y. Kitamu, H. Takemura, and F. Kishino, “A Simple andEfficient Method for Accurate Collision Detection among Deform-able Polyhedral Objects in Arbitrary Motion,” Proc. Virtual RealityAnn. Int’l Symp., pp. 136-145, 1995.

[44] S. Suri, P.M. Hubbard, and J.F. Hughes, “Collision Detection inAspect and Scale Bounded Polyhedra,” Proc. Ninth ACM-SIAMSymp. Discrete Algorithms, pp. 127-136, Jan. 1998.

[45] D. Terzopoulos and K. Fleischer, “Modeling Inelastic Deforma-tion: Viscoelasticity, Plasticity, Fracture,” Computer Graphics (Proc.SIGGRAPH ’88), vol. 22, no. 4, pp. 269-278, 1988.

[46] D. Terzopoulos, J. Platt, A. Barr, and K. Fleischer, “ElasticallyDeformable Models,” Computer Graphics (Proc. SIGGRAPH ’87),vol. 21, no. 4, pp. 205-214, July 1987.

[47] D. Terzopoulos and A. Witkin, “Physically Based Models withRigid and Deformable Components,” IEEE Computer Graphics andApplications, vol. 8, no. 6, pp. 41-51, 1988.

[48] G. van den Bergen, “Efficient Collision Detection of ComplexDeformable Models Using AABB Trees,” J. Graphics Tools, vol. 2,no. 4, pp. 1-14, 1999.

[49] T. Vassilev, B. Spanlang, and Y. Chrysanthou, “Fast ClothAnimation on Walking Avatars,” Computer Graphics Forum,vol. 20, no. 3, pp. 260-267, Sept. 2001.

[50] P. Volino, M. Courchesne, and N. Magnenat-Thalmann, “Versatileand Efficient Techniques for Simulating Cloth and OtherDeformable Objects,” Computer Graphics (SIGGRAPH Proc. 1995),pp. 137-144, Aug. 1995.

[51] P. Volino and N. Magnenat-Thalmann, “Efficient Self-CollisionDetection on Smoothly Discretised Surface Animation UsingGeometrical Shape Regularity,” Computer Graphics Forum, Euro-graphics Proc., vol. 13, no. 3, pp. 155-166, Sept. 1994.

[52] P. Volino and N. Magnenat-Thalmann, “Collision and Self-Collision Detection: Robust and Efficient Techniques for HighlyDeformable Surfaces,” Proc. Eurographics Workshop Animation andSimulation, 1995.

[53] P. Volino and N. Magnenat-Thalmann, “Accurate CollisionResponse on Polygonal Meshes,” Proc. Computer Animation Conf.,pp. 179-188, 2000.

[54] P. Volino and N. Magnenat-Thalmann, “Implementing Fast ClothSimulation with Collision Response,” Computer Graphics Int’l,pp. 257-268, 2000.

[55] P. Volino, N. Magnenat-Thalmann, J.H. Shen, and D. Thalmann,“An Evolving System for Simulating Clothes on Virtual Actors,”IEEE Computer Graphics and Applications, vol. 16, no. 5, pp. 42-51,Sept. 1996.

[56] Y. Yang and N. Magnenat-Thalmann, “An Improved Algorithmfor Collision Detection in Cloth Animation with Human Body,”Proc. First Pacific Conf. Computer Graphics and Applications, pp. 237-251, 1993.

[57] M.J. Zyda, D.R. Pratt, D. Osborne, and J.G. Monahan, “NPSNET:Real-Time Collision Detection and Response,” The J. Visualizationand Computer Animation, vol. 4, no. 1, pp. 13-24, 1993.

George Baciu holds degrees in computerscience and applied mathematics and the PhDdegree in systems eesign Engineering fromUniversity of Waterloo, where he was been amember of the Computer Graphics Lab and thePattern Analysis and Machine Intelligencegroup. He is currently an associate Professorin the Department of Computing at the HongKong Polytechnic University (HKUST), which hejoined in 1993 and where he initiated one of the

first graduate and undergraduate computer graphics curricula in HongKong. He was the founding director of the Graphics And MusicExperimentation (GAME) Laboratory at HKUST where he conductedresearch in motion synthesis, 3D user interfaces, rendering, geometricmodeling, and animation. Currently, he serves as the founding directorof the Graphics And Multimedia Applications (GAMA) Laboratory at theHong Kong Polytechnic University where he continues research in3D motion capture, motion analysis and synthesis, 3D geometricmodeling, and network graphics. He is a member of the IEEE and ACM.

Wingo Sai-Keung Wong received the BEngand MPhil degrees in computer science in1996 and 1999, respectively, from the HongKong University of Science and Technology(HKUST). Currently, he is a PhD candidate inthe Department of Computer Science atHKUST. In 2001, he joined the Hong KongPolytechnic University as an assistant lec-turer, where he teaches courses in program-ming languages and computer graphics. His

research interests include 3D object collision detection, clothsimulation, 3D animation, and visualization.

. For more information on this or any computing topic, please visitour Digital Library at www.computer.org/publications/dlib.


Image-Based Collision Detection for Deformable Cloth Models

Documents

Transcript of Image-Based Collision Detection for Deformable Cloth Models