Fast Penetration Depth Computation for Physically-based Animation Y. Kim, M. Otaduy, M. Lin and D.

Slides:



Advertisements
Similar presentations
The UNIVERSITY of NORTH CAROLINA at CHAPEL HILL CULLIDE: Interactive Collision Detection Between Complex Models in Large Environments using Graphics Hardware.
Advertisements

1 Motion and Manipulation Configuration Space. Outline Motion Planning Configuration Space and Free Space Free Space Structure and Complexity.
Complete Motion Planning
Geometric Representations & Collision Detection Kris Hauser I400/B659: Intelligent Robotics Spring 2014.
Visibility Culling using Hierarchical Occlusion Maps Hansong Zhang, Dinesh Manocha, Tom Hudson, Kenneth E. Hoff III Presented by: Chris Wassenius.
Continuous Collision Detection: Progress and Challenges Gino van den Bergen dtecta
Introduction to Collision Detection & Fundamental Geometric Concepts Ming C. Lin Department of Computer Science University of North Carolina at Chapel.
Proximity Computations between Noisy Point Clouds using Robust Classification 1 Jia Pan, 2 Sachin Chitta, 1 Dinesh Manocha 1 UNC Chapel Hill 2 Willow Garage.
Haptic Rendering using Simplification Comp259 Sung-Eui Yoon.
1 Dr. Scott Schaefer Hidden Surfaces. 2/62 Hidden Surfaces.
The UNIVERSITY of NORTH CAROLINA at CHAPEL HILL Fast C-obstacle Query Computation for Motion Planning Liang-Jun Zhang 12/13/2005 Liang-Jun Zhang 1 Young.
Pauly, Keiser, Kobbelt, Gross: Shape Modeling with Point-Sampled GeometrySIGGRAPH 2003 Shape Modeling with Point-Sampled Geometry Mark Pauly Richard Keiser.
1 Last lecture  Path planning for a moving Visibility graph Cell decomposition Potential field  Geometric preliminaries Implementing geometric primitives.
Adaptive Dynamic Collision Checking for Many Moving Bodies Mitul Saha Department of Computer Science, Stanford University. NSF-ITR Workshop Collaborators:
UNC Chapel Hill M. C. Lin References Collision Detection between Geometric Models: A Survey, by M. Lin and S. Gottschalk, Proc. of IMA Conference on Mathematics.
UNC Chapel Hill M. C. Lin COMP259: Physically-Based Modeling, Simulation & Animation Tues/Thur 12:30pm – 1:45pm (SN 011)
UNC at CHAPEL HILL & Ewha Womans University Generalized Penetration Depth Computation Liang-Jun Zhang Gokul Varadhan Dinesh Manocha Dept of Computer Sci.
Adapted from: CULLIDE: Interactive Collision Detection Between Complex Models in Large Environments using Graphics Hardware Naga K. Govindaraju, Stephane.
Fast Computation of Generalized Voronoi Diagrams Using Graphics Hardware Kenneth E. Hoff III, Tim Culver, John Keyser, Ming Lin, and Dinesh Manocha University.
CS 326 A: Motion Planning robotics.stanford.edu/~latombe/cs326/2004/index.htm Collision Detection and Distance Computation: Feature Tracking Methods.
The UNIVERSITY of NORTH CAROLINA at CHAPEL HILL Continuous Collision Detection David Knott COMP 259 class presentation.
Exact Collision Checking of Robot Paths Fabian Schwarzer Mitul Saha Jean-Claude Latombe Computer Science Department Stanford University.
Dynamic Maintenance and Self Collision Testing for Large Kinematic Chains Lotan, Schwarzer, Halperin, Latombe.
Self-Collision Detection and Prevention for Humanoid Robots James Kuffner et al. presented by Jinsung Kwon.
P. Ögren (KTH) N. Leonard (Princeton University)
Ray Tracing Dynamic Scenes using Selective Restructuring Sung-eui Yoon Sean Curtis Dinesh Manocha Univ. of North Carolina at Chapel Hill Lawrence Livermore.
CS 326 A: Motion Planning robotics.stanford.edu/~latombe/cs326/2004/index.htm Collision Detection and Distance Computation.
OBBTree: A Hierarchical Structure for Rapid Interference Detection Gottschalk, M. C. Lin and D. ManochaM. C. LinD. Manocha Department of Computer Science,
Adaptive Dynamics of Articulated Bodies. Articulated bodies in Computer Graphics – Humans, hair, animals – Trees, forests, grass – Deformable bodies –
UNC Chapel Hill M. C. Lin Overview of Last Lecture About Final Course Project –presentation, demo, write-up More geometric data structures –Binary Space.
Haptic Cloth Rendering 6th Dutch-Belgian Haptics Meeting TUDelft, 21 st June 2006 Lode Vanacken Expertise centre for Digital Media (EDM) Hasselt University.
NUS CS 5247 David Hsu Minkowski Sum Gokul Varadhan.
The UNIVERSITY of NORTH CAROLINA at CHAPEL HILL Constraint-Based Motion Planning using Voronoi Diagrams Maxim Garber and Ming C. Lin Department of Computer.
The UNIVERSITY of NORTH CAROLINA at CHAPEL HILL Collision Detection for Deformable Objects Xin Huang 16/10/2007.
The University of North Carolina at CHAPEL HILL A Simple Path Non-Existence Algorithm using C-obstacle Query Liang-Jun Zhang.
Heuristics for 3D model decomposition Presented by Luv Kohli COMP258 December 11, 2002.
CS 326A: Motion Planning ai.stanford.edu/~latombe/cs326/2007/index.htm Collision Detection and Distance Computation.
The UNIVERSITY of NORTH CAROLINA at CHAPEL HILL Geometric Computations on GPU: Proximity Queries Avneesh Sud &Dinesh Manocha.
1 Single Robot Motion Planning Liang-Jun Zhang COMP Sep 22, 2008.
CS 326A: Motion Planning ai.stanford.edu/~latombe/cs326/2007/index.htm Collision Detection and Distance Computation.
Collision Detection David Johnson Cs6360 – Virtual Reality.
Computer graphics & visualization Collision Detection – Narrow Phase.
Computer Graphics Group Tobias Weyand Mesh-Based Inverse Kinematics Sumner et al 2005 presented by Tobias Weyand.
CSE 381 – Advanced Game Programming Quickhull and GJK.
Computer Graphics 2 Lecture 8: Visibility Benjamin Mora 1 University of Wales Swansea Pr. Min Chen Dr. Benjamin Mora.
Quick-CULLIDE: Efficient Inter- and Intra- Object Collision Culling using Graphics Hardware Naga K. Govindaraju, Ming C. Lin, Dinesh Manocha University.
Interactive Geometric Computations using Graphics Processors Naga K. Govindaraju UNC Chapel Hill.
Collision and Proximity Queries Dinesh Manocha Department of Computer Science University of North Carolina
Efficient Raytracing of Deforming Point-Sampled Surfaces Mark Pauly Leonidas J. Guibas Bart Adams Philip Dutré Richard Keiser Markus Gross.
View-dependent Adaptive Tessellation of Spline Surfaces
Stable 6-DOF Haptic Rendering with Inner Sphere Trees René Weller, Gabriel Zachmann Clausthal University, Germany IDETC/CIE.
Presented by Paul Phipps
CULLIDE: Interactive Collision Detection Between Complex Models in Large Environments using Graphics Hardware Presented by Marcus Parker By Naga K. Govindaraju,
01/28/09Dinesh Manocha, COMP770 Visibility Computations Visible Surface Determination Visibility Culling.
Hierarchical Occlusion Map Zhang et al SIGGRAPH 98.
A Fast Algorithm for Incremental Distance Calculation Ming C. Lin and John F. Canny University of California, Berkeley 1991 Original slides by Adit Koolwal.
Interactive Continuous Collision Detection for Polygon Soups Xin Huang 11/20/2007.
A Fast Algorithm for Incremental Distance Calculation Ming C. Lin & John Canny University of California, Berkeley 1991 Presentation by Adit Koolwal.
GJK Supplement Reference: SIGGRAPH2004 Course Note Original Reference: A Fast Procedure for Computing the Distance between Objects in Three-Dimensional.
Minkowski Sums and Distance Computation Eric Larsen COMP
Stable 6-DOF Haptic Rendering with Inner Sphere Trees
Collision Detection Spring 2004.
You can check broken videos in this slide here :
COMP259: Physically-Based Modeling, Simulation & Animation
References Additional lecture notes for 2/18/02.
C-obstacle Query Computation for Motion Planning
COMP259: Physically-Based Modeling, Simulation & Animation
Young J. Kim Ming C. Lin Dinesh Manocha
References Collision Detection between Geometric Models: A Survey, by M. Lin and S. Gottschalk, Proc. of IMA Conference on Mathematics of Surfaces 1998.
Computer Animation Algorithms and Techniques
Presentation transcript:

Fast Penetration Depth Computation for Physically-based Animation Y. Kim, M. Otaduy, M. Lin and D. Manocha Computer Science UNC – Chapel Hill Y. Kim, M. Otaduy, M. Lin and D. Manocha Computer Science UNC – Chapel Hill

Proximity Queries and PD Collision Detection Separation Distance Penetration Depth d d

Definition  Penetration Depth (PD)  Minimum translational distance to separate two intersecting objects  Penetration Depth (PD)  Minimum translational distance to separate two intersecting objects PD

Motivation  Contact Handling in Rigid Body Simulation  Time stepping method »Check the contact at fixed intervals  Penalty-based method  Contact Handling in Rigid Body Simulation  Time stepping method »Check the contact at fixed intervals  Penalty-based method

Motivation  Time stepping method  Estimate the time of collision (TOC)  Time stepping method  Estimate the time of collision (TOC) T = t 0 T = t 1 T = t 2 T = t ?

Motivation  Time stepping method using PD 1.Compute the penetration depth 2.Estimate the TOC by interpolation in time domain  Time stepping method using PD 1.Compute the penetration depth 2.Estimate the TOC by interpolation in time domain T = t k T = t 1 T = t 2

Motivation  Penalty-based Method T = t 0 T = t 1 T = t 2

PD Application  Rigid body dynamic simulation  Robot motion planning for autonomous agents and animated characters  Haptic rendering  Tolerance verification for CAD models  Rigid body dynamic simulation  Robot motion planning for autonomous agents and animated characters  Haptic rendering  Tolerance verification for CAD models

Previous Work  Convex polytopes  [Cameron ’86 ’97], [Dobkin et al. ’93], [Agarwal et al. ’00], [Bergen ’01], [Kim et al. ’02]  Local solutions for deformable models  [Susan and Lin ’01], [Hoff et al. ’01]  No solutions existed for non-convex models  Convex polytopes  [Cameron ’86 ’97], [Dobkin et al. ’93], [Agarwal et al. ’00], [Bergen ’01], [Kim et al. ’02]  Local solutions for deformable models  [Susan and Lin ’01], [Hoff et al. ’01]  No solutions existed for non-convex models

Overview  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation

Overview  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation

Preliminaries  Local solutions might not have any relevance to a global solution Local PD solutions PD Global PD solution

Preliminaries  Minkowski sum and PD  P  -Q = { p-q | p  P, q  Q }  PD := minimum distance between O Q-P and the surface of P  -Q  Minkowski sum and PD  P  -Q = { p-q | p  P, q  Q }  PD := minimum distance between O Q-P and the surface of P  -Q  P  -Q P O Q-P OPOP OQOQ Q

Preliminaries  Minkowski sum and PD  P  -Q = { p-q | p  P, q  Q }  PD := minimum distance between O Q-P and the surface of P  -Q  Minkowski sum and PD  P  -Q = { p-q | p  P, q  Q }  PD := minimum distance between O Q-P and the surface of P  -Q  P  -Q P O Q-P OPOP OQOQ Q

Preliminaries  Decomposition property of Minkowski sum  If P = P 1  P 2, then P  Q = (P 1  Q)  (P 2  Q)  Computing Minkowski sum  Convex: O(n log(n)) »where n is the number of features  Non-Convex: O(n 6 ) computational complexity »In theory, use the convolution or the decomposition property »In practice, very hard to implement.  Decomposition property of Minkowski sum  If P = P 1  P 2, then P  Q = (P 1  Q)  (P 2  Q)  Computing Minkowski sum  Convex: O(n log(n)) »where n is the number of features  Non-Convex: O(n 6 ) computational complexity »In theory, use the convolution or the decomposition property »In practice, very hard to implement.

Overview  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation

PD Algorithm : A Hybrid Approach  P  Q = (P 1  Q)  (P 2  Q)  where P = P 1  P 2  P  Q = (P 1  Q)  (P 2  Q)  where P = P 1  P 2

PD Algorithm : A Hybrid Approach  P  Q  P  Q = (P 1  Q)  (P 2  Q)  where P = P 1  P 2  P  Q  P  Q = (P 1  Q)  (P 2  Q)  where P = P 1  P 2

PD Algorithm : A Hybrid Approach  P  Q = (P 1  Q)  (P 2  Q) P = P 1  P 2  where P = P 1  P 2  Precomputation: Decomposition  P  Q = (P 1  Q)  (P 2  Q) P = P 1  P 2  where P = P 1  P 2  Precomputation: Decomposition

PD Algorithm : A Hybrid Approach P 1  QP 2  Q  P  Q = (P 1  Q)  (P 2  Q)  where P = P 1  P 2  Precomputation: Decomposition  Runtime:  Object Space: Pairwise Minkowski sum computation P 1  QP 2  Q  P  Q = (P 1  Q)  (P 2  Q)  where P = P 1  P 2  Precomputation: Decomposition  Runtime:  Object Space: Pairwise Minkowski sum computation

PD Algorithm : A Hybrid Approach   P  Q = (P 1  Q)  (P 2  Q)  where P = P 1  P 2  Precomputation: Decomposition  Runtime:  Object Space: Pairwise Minkowski sum computation  Image Space: Union by graphics hardware   P  Q = (P 1  Q)  (P 2  Q)  where P = P 1  P 2  Precomputation: Decomposition  Runtime:  Object Space: Pairwise Minkowski sum computation  Image Space: Union by graphics hardware

PD Computation Pipeline Pairwise Minkowski Sum (Object Space) Precomputation Run-time PD Query Closest Point Query (Image Space) Convex Decomposition

Convex Surface Decomposition  [Ehmann and Lin ’01]  Decompose an object into a collection of convex surface patches  Compute the convex hull of each surface patch  [Ehmann and Lin ’01]  Decompose an object into a collection of convex surface patches  Compute the convex hull of each surface patch

Pairwise Minkowski Sum  Algorithms  Convex hull property of convex Minkowski sum » P  Q = ConvHull{v i +v j | v i  V P, v j  V Q }, where P and Q are convex polytopes.  Topological sweep on Gauss map [Guibas ’87]  Incremental surface expansion [Rossignac ’92]  Algorithms  Convex hull property of convex Minkowski sum » P  Q = ConvHull{v i +v j | v i  V P, v j  V Q }, where P and Q are convex polytopes.  Topological sweep on Gauss map [Guibas ’87]  Incremental surface expansion [Rossignac ’92]

Closest Point Query  Goal  Given a collection of convex Minkowski sums, compute the shortest distance from the origin to the surface of their union  An exact solution is computationally expensive  Approximation using graphics hardware  Goal  Given a collection of convex Minkowski sums, compute the shortest distance from the origin to the surface of their union  An exact solution is computationally expensive  Approximation using graphics hardware

 Main Idea  Incrementally expand the current front of the boundary  Main Idea  Incrementally expand the current front of the boundary Closet Point Query

Closest Point Query 1.Render front faces, and open up a window where z-value is less than the current front 2.Render back faces w/ z-greater-than test 3.Repeat the above m times, where m := # of obj’s 1.Render front faces, and open up a window where z-value is less than the current front 2.Render back faces w/ z-greater-than test 3.Repeat the above m times, where m := # of obj’s

Closest Point Query 1.Render front faces, and open up a window where z-value is less than the current front 2.Render back faces w/ z-greater-than test 3.Repeat the above m times, where m := # of obj’s 1.Render front faces, and open up a window where z-value is less than the current front 2.Render back faces w/ z-greater-than test 3.Repeat the above m times, where m := # of obj’s

Overview  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation

Motivation  PD is shallow in practice.  Convex decomposition has O(n) convex pieces in practice.  Culling strategy is suitable and very effective.  PD is shallow in practice.  Convex decomposition has O(n) convex pieces in practice.  Culling strategy is suitable and very effective.

Object Space Culling  Basic Idea  If we know the upper bound on PD, u PD, we do not need to compute the Mink. sum of pairs whose Euclidean dist is more than u PD  Basic Idea  If we know the upper bound on PD, u PD, we do not need to compute the Mink. sum of pairs whose Euclidean dist is more than u PD u PD

Object Space Culling  Basic Idea  If we know the upper bound on PD, u PD, we do not need to compute the Mink. sum of pairs whose Euclidean dist is more than u PD  Basic Idea  If we know the upper bound on PD, u PD, we do not need to compute the Mink. sum of pairs whose Euclidean dist is more than u PD u PD PD

Object Space Culling  Basic Idea  If we know the upper bound on PD, u PD, we do not need to compute the Mink. sum of pairs whose Euclidean dist is more than u PD  Basic Idea  If we know the upper bound on PD, u PD, we do not need to compute the Mink. sum of pairs whose Euclidean dist is more than u PD

Image Space Culling  Rendering only once for the Minkowski sums containing the origin  Refine the upper bound for every view frustum  View frustum culling  Rendering only once for the Minkowski sums containing the origin  Refine the upper bound for every view frustum  View frustum culling

 BVH Construction (Ehmann and Lin ’01) Hierarchical Culling  Hierarchical Culling

 BVH Construction (Ehmann and Lin ’01) Hierarchical Culling  Hierarchical Culling

Hierarchical Refinement Culling Pairwise Minkowski Sum BVH Construction Precomputation Run-time PD Query Refine the current PD estimate, and go to the next level of BVH Closest Point Query Convex Decomposition

PD Benchmarks 0.3 sec (4 hr) 3.7 sec (4 hr) 1.9 sec (177 hr) 0.4 sec (7 min) With Accel. (Without Accel.) With Accel. (Without Accel.) Touching ToriInterlocked ToriInterlocked GratesTouching Alphabets

PD Benchmarks ModelsTri Convex Pieces PD w/o Accel. PD w/ Accel Touching Tori hr0.3 sec Interlocked Tori hr3.7 sec Interlocked Grates444, , hr1.9 sec Touching Alphabets 144,15242, 437 min0.4 sec

Hierarchical Culling Example LevelCull RatioMink SumHW QueryPD est 331.2%0.219 sec0.220 sec %0.165 sec0.146 sec %1.014 sec1.992 sec0.50

Implementation  SWIFT++ [Ehmann and Lin ’01]  QHULL  OpenGL for closest point query  SWIFT++ [Ehmann and Lin ’01]  QHULL  OpenGL for closest point query

Implementation void DrawUnionOfConvex(ConvexObj *ConvexObjs, int NumConvexObjs) { glClearDepth(0); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glEnable(GL_STENCIL_TEST); for (int i=0; i<NumConvexObjs; i++) for (int j=0; j<NumConvexObjs; j++) { glDepthMask(0); glColorMask(0,0,0,0); glDepthFunc(GL_LESS); glStencilFunc(GL_ALWAYS,1,1); glStencilOp(GL_KEEP,GL_REPLACE,GL_KEEP); ConvexObjs[j].DrawFrontFaces(); glDepthMask(1); glColorMask(1,1,1,1); glDepthFunc(GL_GREATER); glStencilFunc(GL_EQUAL,0,1); glStencilOp(GL_ZERO,GL_KEEP,GL_KEEP); ConvexObjs[j].DrawBackFaces(); } void DrawUnionOfConvex(ConvexObj *ConvexObjs, int NumConvexObjs) { glClearDepth(0); glClearStencil(0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); glEnable(GL_DEPTH_TEST); glEnable(GL_STENCIL_TEST); for (int i=0; i<NumConvexObjs; i++) for (int j=0; j<NumConvexObjs; j++) { glDepthMask(0); glColorMask(0,0,0,0); glDepthFunc(GL_LESS); glStencilFunc(GL_ALWAYS,1,1); glStencilOp(GL_KEEP,GL_REPLACE,GL_KEEP); ConvexObjs[j].DrawFrontFaces(); glDepthMask(1); glColorMask(1,1,1,1); glDepthFunc(GL_GREATER); glStencilFunc(GL_EQUAL,0,1); glStencilOp(GL_ZERO,GL_KEEP,GL_KEEP); ConvexObjs[j].DrawBackFaces(); }

Accuracy of PD computation  Our algorithm computes an upper bound to PD  Image space computation determines the tightness of the upper bound  Pixel resolution  Z-buffer precision  In practice, with 256  256 pixel resolution, the algorithm rapidly converges to the PD  Our algorithm computes an upper bound to PD  Image space computation determines the tightness of the upper bound  Pixel resolution  Z-buffer precision  In practice, with 256  256 pixel resolution, the algorithm rapidly converges to the PD

Overview  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation  Preliminaries  Minkowski sum-based Framework  Basic PD Algorithm: A Hybrid Approach  Acceleration Techniques  Object Space Culling  Hierarchical Refinement  Image Space Culling  Application to Rigid Body Dynamic Simulation

 Interpenetration is often unavoidable in numerical simulations  Need for a consistent and accurate measure of PD  Penalty-based Method  F = (k d)n »d: PD, n: PD direction, k:stiffness constant  Interpenetration is often unavoidable in numerical simulations  Need for a consistent and accurate measure of PD  Penalty-based Method  F = (k d)n »d: PD, n: PD direction, k:stiffness constant Application to Rigid Body Simulation

Application to Rigid Body Simulation  Time Stepping Method  Estimate the time of collision (TOC) »s: separation dist before interpenetration »d: PD, n: PD dir after interpenetration »v s : relative velocity of closest features »v d : relative velocity of PD features  Time Stepping Method  Estimate the time of collision (TOC) »s: separation dist before interpenetration »d: PD, n: PD dir after interpenetration »v s : relative velocity of closest features »v d : relative velocity of PD features

Application to Rigid Body Simulation  x(t) : 1D distance function between closest features and PD features projected to PD direction  x(0) = s, x(T) = d  dx/dt(0) = v sn, dx/dt(T) = v dn  Compute the roots of x(t) = 0  x(t) : 1D distance function between closest features and PD features projected to PD direction  x(0) = s, x(T) = d  dx/dt(0) = v sn, dx/dt(T) = v dn  Compute the roots of x(t) = 0

Rigid Body Simulation Demo Example 1 Average complexity: 250 triangles 60 Convex Pieces / Object Example 2 Average complexity: 250 triangles 200 letters and alphabets

Rigid Body Simulation Demo

Contributions  First practical PD algorithm using a hybrid approach  Acceleration techniques:  Object space culling  Image space culling  Hierarchical refinement  Application to rigid body simulation  First practical PD algorithm using a hybrid approach  Acceleration techniques:  Object space culling  Image space culling  Hierarchical refinement  Application to rigid body simulation

Future Work  More optimizations on  Closest point query  Pairwise Minkowski sum  More performance comparisons  Accuracy and running time of PD algorithm  Other RBD simulation approaches  Extension to rotational PD  More optimizations on  Closest point query  Pairwise Minkowski sum  More performance comparisons  Accuracy and running time of PD algorithm  Other RBD simulation approaches  Extension to rotational PD

Acknowledgement  Kenneth Hoff  Stephen Ehmann  ARO  DOE  NSF  ONR  Intel  Kenneth Hoff  Stephen Ehmann  ARO  DOE  NSF  ONR  Intel

Thank you