Collision Detection for Deformable Models - PowerPoint PPT Presentation

1 / 48
About This Presentation
Title:

Collision Detection for Deformable Models

Description:

... space technique to do collision culling. Utilize graphics hardware ... Can still be powerful for culling, followed by object-space exact collision detection ... – PowerPoint PPT presentation

Number of Views:41
Avg rating:3.0/5.0
Slides: 49
Provided by: giclCs
Category:

less

Transcript and Presenter's Notes

Title: Collision Detection for Deformable Models


1
Collision Detection for Deformable Models
  • Huai-Ping Lee
  • lhp_at_cs.unc.edu

2
Differences in Deformable Models
  • Collision and self-collisions
  • Self collisions are often neglected for rigid
    bodies
  • Preprocessing
  • Data structure need to be updated frequently
  • Performance
  • Efficiency is very important

3
Hybrid Approach LAM01
  • Goal adapt BVHs to handle deformable models
    efficiently
  • Some modification in building and updating the
    tree
  • Efficiency of updating hierarchies is more
    important than the tightness of BVs
  • AABBs are preferred

4
Hybrid Approach LAM01
  • For a bottom-up update strategy using AABBs
    vdB97, 8-ary tree version is 10 to 20 percent
    faster than binary version
  • Fewer nodes need to be updated (if using top-down
    approach)
  • Recursion depth during collision tests is lower

5
Hybrid Approach LAM01
  • Bounding volume pre-processing
  • 8-ary AABB tree built in top-down manner
  • A parent AABB is split along three axis to form
    eight child sub-volumes
  • No significant difference between ways of
    choosing split planes
  • Center of the box or average point of all polygons

6
Hybrid Approach LAM01
  • Run-time update
  • Hybrid of top-down and bottom-up updates
  • For a tree with depth n, initially update the n/2
    first levels bottom-up.
  • During a collision traversal, update those
    non-updated nodes top-down as needed

7
Hybrid Approach LAM01
  • Results for hard cases
  • All intersecting face pairs are reported

8
Hybrid Approach LAM01
  • Results for simple cases
  • Only the first intersecting face pair is reported

9
Hybrid Approach LAM01
  • Improved bounding volume hierarchies for
    deformable models
  • More efficient update
  • Self-collisions are not considered

10
Lazy Update MKE03
  • Another improvement to BVHs
  • Using k-DOPs
  • Build the tree top-down
  • Also reported that 4-ary and 8-ary trees are
    better
  • Lazy update
  • Re-inserts the vertices into the leaf k-DOPs and
    build internal nodes bottom-up
  • Also want to detect self-collision

11
Lazy Update MKE03
  • Knowing maximum velocity of the vertices, some
    BVs need not be updated
  • Parts of the hierarchy where vertices do not
    travel more than a distance b can be omitted
    during the hierarchy update for a time t b / v,
    if proximities smaller than eclose 2b is to be
    detected
  • The BVs have been fattened by eclose / 2

12
Lazy Update MKE03
  • BVHs are still inappropriate when detecting
    self-collisions
  • bounding boxes will always find contacts between
    adjacent sub-objects
  • Test the BVH against itself?
  • Need to skip some tests between adjacent
    sub-surfaces
  • Previous solutions VMT94 and Pro97
  • This paper uses method in Pro97

13
Curvature Criterion VMT94
  • If There exists a vector V for which N.V gt 0 at
    every point of S
  • And The projection of C on a plane orthogonal to
    V along the direction of V has no
    self-intersections
  • Then There are no self-collisions on the surface
    S.

14
Curvature Criterion VMT94
  • For each sub-surface
  • Search for V
  • If V exists, test the projected region for
    self-intersection
  • If both succeeded, there is no self-intersection
  • Otherwise, check for self intersections in the
    sub-surface

15
Curvature Criterion VMT94
  • V can be propagated bottom-up in the tree
  • Divide a sphere into 14 unit vectors
  • In each node, keep those vectors that have
    positive dot products with all the normals in the
    BV

16
Normal Cones Pro97
  • In each BV, keep a cone representing a super set
    of normal directions
  • Parent cones are easily computed from child cones
  • a ß/2 max(a1, a2)
  • If a?p, check for self-intersection

17
Lazy Update MKE03
  • Another way to improve hierarchy update
  • Also detects self-intersection using normal cones
  • Results
  • HUHierarchy Update, CTCollision Test

18
Morphing of Tree LAM03
  • Accelerate the special case in which models are
    deformed by mesh morphing
  • First establish the correspondence between
    geometric parts in reference models, assuming all
    models have the same number of vertices and mesh
    connectivity
  • Interpolate between these parts
  • The models in each frame are formed by linear
    blending the n reference models

19
Morphing of Tree LAM03
  • Tree building (top-down)
  • Add one BV per node in the tree for each
    reference model
  • Namely, each node in the tree contain n BVs
  • BVs are updated by blending the bounding volumes
    of corresponding sub-models
  • using the same weights for linear blending

20
Morphing of Tree LAM03
  • Experimentthree reference models

21
Morphing of Tree LAM03
  • Compared with hybrid method LAM01

22
Image-Space Techniques
  • Work with 2D or 3D discretized representation of
    objects
  • Do not perform exact collision detection due to
    discretization error
  • Make use of graphics hardware
  • Have to worry about bandwidth to and from
    graphics card
  • Too many read-backs of buffers (depth, color,
    stencil) will make it slower than using only CPU

23
Layered Depth Image (LDI) Decomposition HTG03
  • Use discretized 3D representation to accelerate
    collision detection
  • Look like this

24
Layered Depth Image (LDI) Decomposition HTG03
  • Stage 1 Compute AABB intersection for a pair of
    objects (Volume-of-Intersect, VoI)
  • Stage 2 Compute the two LDIs restricted to the
    VoI
  • like scan-line conversions

25
Layered Depth Image (LDI) Decomposition HTG03
  • How to compute LDIs?
  • Render a 2D projection for each depth value
  • Like scan-conversions
  • Need to read back the rendered image from frame
    buffer
  • For simple environment, graphics hardware version
    runs slower than CPU version

26
Layered Depth Image (LDI) Decomposition HTG03
  • Stage 3 Perform the actual collision detection
  • (3a) Count the overlapping pixels
  • (3b) Check if vertices of an object are in
    another objects volume

27
Layered Depth Image (LDI) Decomposition HTG03
  • Resultsusing intersection volume (3a)
  • Depth complexity is the number of layers in LDI

28
Layered Depth Image (LDI) Decomposition HTG03
  • Resultsusing vertex-in-volume
  • Times for LDI generation for entire objects

29
Layered Depth Image (LDI) Decomposition HTG03
  • Does not need much pre-computation
  • Can also detect self-collision
  • By labeling entry leaving points explicitly
  • Accuracy is related to the resolution of LDI
  • Restricted to water-tight models
  • Otherwise the scan-conversion will fail
  • Need buffer read-backs
  • Use graphics hardware for complex scenes!

30
CULLIDE GRLM03
  • A solution to N-body problem
  • Does not use 3D discretized representation of the
    models
  • Only use visibility queries
  • Cull those objects that cannot be colliding
  • Keep a potentially colliding set (PCS)
  • For large environment

31
CULLIDE GRLM03
  • Given an environment composed of n objects, O1,
    O2, , On
  • If Oi is fully-visible with respect to all other
    objects, then Oi cannot collide with any other
    object, thus is not in PCS
  • Choose three axis to perform orthogonal
    projection
  • The second pass tests visibility of sub-objects
    in a similar manner
  • Only test those still in the PCS after first pass

32
CULLIDE GRLM03
  • Final step
  • The primitives remaining in the PCS are tested
    with exact collision detection methods
  • Results

100 deforming cylinders
100 cylinders 200 polygons
33
CULLIDE GRLM03
  • Visibility query done by graphics hardware
  • Does not need to read back buffers
  • Accuracy governed by image resolution
  • Errors can be overcome by fattened
    representation
  • GLM04
  • Does not need pre-computation
  • Suitable for any polygonal mesh, large scene
  • Cannot be used for self-collision
  • Adjacent faces cannot be culled
  • Need decomposition of the mesh?

34
Chromatic Decomposition Govindaraju et al. 05
  • Modify CULLIDE to handle self-collision
  • transforms self-collision detection into
    pair-wise N-body CD between non-adjacent
    primitives
  • Decompose the mesh into k independent sets
    S1,,Sk
  • For every pair of independent set, (Si, Sj),
    ensure each primitive in Si has only one adjacent
    primitive that is in Sj
  • To simplify the adjacency
  • Building a corresponding graph G, and decompose
    it with graph coloring

35
Graph Coloring Govindaraju et al. 05
  • Construct a graph G (V, E)
  • Each primitive pi correspond to a vertex V(pi) in
    V
  • Add an edge (V(pl), V(pm)) to E if
  • Primitives pl and pm are vertex-adjacent
  • There exists primitive p in the mesh that is
    adjacent to both pl and pm
  • Ensures each primitive in Si has only one
    adjacent primitive that is in Sj

36
Graph Coloring Govindaraju et al. 05
  • Each node is given a color that is different from
    its neighbors in graph G
  • Nodes with the same color forms an independent
    set
  • Each independent set has a PCS

37
Reordering Govindaraju et al. 05
  • Consider each pair Si and Sj, compute pairs of
    adjacent primitives between them
  • Give the adjacent primitives the same index

38
Collision Culling Govindaraju et al. 05
  • Collision culling using AABB tree
  • Test the tree against itself
  • Ignore overlaps with adjacent primitives here
  • 2.5D test build PCS for each set
  • 1st pass traverse the primitives in Si from last
    to first
  • Test if pim is fully-visible against previously
    rendered primitives in Si and Sj, namely pigtm
    pjgtm
  • 2nd pass traverse the primitives from first to
    last, namely test pim against piltm pjltm

39
GPU Culling Govindaraju et al. 05
40
AABB Culling vs. GPU culling Govindaraju et al.
05
  • Results of culling

41
Exact Tests Govindaraju et al. 05
  • For the primitives left in the PCS, perform exact
    intersection tests on non-adjacent primitives
  • Merge the PCS of all independent sets
  • Use AABB tree to test these primitives
  • For adjacent primitives, perform elementary EE
    and VF tests, but do not test the shared edge or
    vertex

42
Benchmarks Govindaraju et al. 05
More than 23K triangles 400-550ms during each step
13K triangles 400-500ms during each step
32,500 triangles each curtain 100ms for each
curtain
Path planning for a deformable object 60-90ms
43
Comparison Govindaraju et al. 05
44
Chromatic Decomposition Govindaraju et al. 05
  • Transform self-collision detection into N-body
    collision detection by decomposing the mesh
  • Use BVHs and image-space technique to do
    collision culling
  • Utilize graphics hardware

45
Conclusion
  • BVHs are still an important tool for collision
    detection for deformable objects
  • Need to optimize update procedure
  • Self-collision can be culled in object space
  • Curvature criterion (object space)
  • Decompose into independent set
  • Image-space techniques can be accelerated by
    graphics hardware
  • But accuracy is limited by discretization
  • Can still be powerful for culling, followed by
    object-space exact collision detection

46
Reference
  • Lin, M. C., and Manocha, D. 2004. Collision and
    proximity queries. In Handbook of Discrete and
    Computational Geometry, 2nd Ed., J. E. Goodman
    and J. O'Rourke, Eds. CRC Press LLC, Boca Raton,
    FL, ch. 35, 787.807.
  • Teschner, M., Kimmerle, S., Heidelberger, B.,
    Zachmann, G., Raghupathi, L., Fuhrmann, A., Cani,
    M.-P., Faure, F., Magnenat-Thalmann, N.,
    Strasser, W., and Volino, P. 2005. Collision
    detection for deformable objects. Computer
    Graphics Forum
  • Larsson T., Akenine-Möller T. 2001. Collision
    detection for continuously deforming bodies. In
    Eurographics, pp. 325333. short presentation.
  • Larsson T., Akenine-Möller T. 2003. Efficient
    collision detection for models deformed by
    morphing. The Visual Computer 19, 2 (May2003),
    164174.

47
Reference
  • Mezger J., Kimmerle S., Etzmuss O. 2003.
    Hierarchical Techniques in Collision Detection
    for Cloth Animation. Journal of WSCG 11, 2,
    322329.
  • Volino P., Magnenat-Thalmann N. 1994. Efficient
    Self-Collision Detection on Smoothly Discretized
    Surface Animations using Geometrical Shape
    Regularity. Computer Graphics Forum 13, 3,
    155166.
  • Provot, X. 1997. Collision and Self-Collision
    Handling in Cloth Model Dedicated to Design
    Garments. In Graphics Interface 97 (May 1997),
    Canadian Information Processing Society, Canadian
    Human-Computer Communications Society, pp.
    177189.

48
Reference
  • Heidelberger, B., Teschner, M., and Gross, M.
    2003. Real-time volumetic intersections of
    deforming objects. Proc. of Vision, Modeling and
    Visualization.
  • Govindaraju, N., Redon, S., Lin, M. C., and
    Manocha, D. 2003. CULLIDE Interactive Collision
    Detection between Complex Models in Large
    Environments using Graphics Hardware. Proc. of
    Eurographics/SIGGRAPH Workshop on Graphics
    Hardware
  • Govindaraju, N., Knott, D., Jain, N., Kabul, I.,
    Tamstorf, R., Gayle, R., Lin, M. C., and Manocha,
    D. 2005. Interactive Collision Detection between
    Deformable Models using Chromatic Decomposition.
    Proc. of ACM SIGGRAPH.
Write a Comment
User Comments (0)
About PowerShow.com