Download Collision detection

Collision handling:
detection and response
CSE 3541
Matt Boggus
Collision handling overview
detection
response
Point collision detection
Line segment and ray collision detection
Polyhedron-polyhedron collision detection
Bounding volume test
Vertex inside polyhedron test
Concave case
Convex case
Edge-face intersection test
Kinematic response
Penalty method
Geometric modeling primitives
• Point
• Line segment
• Polygon
Terminology – convex and concave
polygons
Convex and concave – line test
Convex and concave – interior angles
Polygon triangulation
split into a set of convex polygons
Generic collision detection test
• Given two objects, the objects are either
colliding or not colliding
• if( objectsCollide ) { collision response }
• Ex: two 2D points, P and Q
– P.x == Q.x && P.y == Q.y
– (P.x – Q.x < errorThreshold) &&
(P.y – Q.y < errorThreshold)
Types of equations
• Explicit
y = f(x)
– Ex: y = 2x+5
• Implicit
0 = f(x,y)
– Ex: x2 + y2 – 1 = 0
• Given some point P = (a,b), compute f(a,b) = c
– c > 0, then P is outside of circle
– c = 0, then P is on boundary of circle
– c < 0, then P is inside circle
• Parametric
(x,y) = (f(t),g(t))
– Ex: x = cos (t), y = sin (t)
• Given a value for t, compute a point (x,y) = P
– P is on boundary of circle
• Note: shapes other than circles can be defined too
Parametric line equation
• P(t) = P0 + t V
– P0 is point on line
– V is direction (or slope) of line
– On line segment ending at P1, t ranges from (0,1)
• Can also be expressed in (x,y) components
– x = P0.x + t * (P1.x – P0.x)
– y = P0.y + t * (P1.y – P0.y)
Point on a line segment
• Given (x,y), is it on a line segment (P1 to P0)?
• x = P0.x + tx * (P1.x – P0.x)
• y = P0.y + ty * (P1.y – P0.y)
• Plug in x, y, P0, P1, solve for tx and ty
• On the segment if 0 ≤ tx = ty ≤ 1
Examples
• P0 = (0,0)
• P1 = (1,1)
•
•
•
•
P = (0.5, 0.5)
P = (-1, -1)
P = (2, 2)
P = (5, 0)
Line intersection – two equations
• Pa = P0 + ta (P1 – P0)
• Pb = P2 + tb (P3 – P2)
• Set them equal, solve for ta and tb
– Note that these are vector equations, not scalars
• Line segment intersection if
– 0 <= ta <= 1, and
– 0 <= tb <= 1
Line intersection – visual example
Point in polygon – ray test
Ray test special cases
Point in convex polygon
(y - y0) (x1 - x0) - (x - x0) (y1 - y0)
> 0, point is to the left of the line
< 0, point is to the right of the line
= 0, point is on the line
Point in convex polygon
(y - y0) (x1 - x0) - (x - x0) (y1 - y0)
For (3,1):
(1)(5) – (3)(0) = 5
For (3,0):
(0)(5) – (3)(0) = 0
For (3,-1):
(-1)(5) – (3)(0) = -5
Polygon Intersection
Contained vertex
Intersecting edges
Polygon intersection – vertex + edges
Collision detection: point-ground plane
p = (x, y, z)
y0
y0
y0
Surface/Polygon normals
Images from http://en.wikipedia.org/wiki/Normal_(geometry)
Collision detection: point-arbitrary plane
p = (x, y, z)
E ( p)  0
E ( p)  ax  by  cz  d  N  p  d
N = (a, b, c)
N
E ( p)  0
E ( p)  0
Terms:
p = point
N = normal vector
D = distance from origin
Collision detection: time of impact
P(ti)
P(ti+?)
P(ti+1)
2 options
-Resolve collision based on new position, P(ti+1)
-Compute fractional time at which collision actually occurred,
resolve collision based on that position, P(ti+?)
Tradeoff: accuracy v. computational cost
3D object collision detection
Collision detection: polyhedra
• Order tests according to computational
complexity and power of detection
1. test bounding volumes for overlap
2. test for vertex of one object inside of other object
3. test for edge of one object intersecting face of other object
Polygon and polyhedra complexity
How many edges?
How many points?
Bounding objects
• Sphere
• Axis aligned bounding box
• Oriented bounding box
Bounding volume construction
• Given a set of points as input, can we
automatically create bounding volumes
– Axis aligned bounding box
– Sphere
– Convex hull
Axis aligned bounding box
Axis aligned bounding box
Bounding sphere
Bounding sphere
Bounding sphere
Bounding sphere
Convex Hull
Best fit convex polyhedron to concave polyhedron
but takes some (one-time) computation
1. Find highest vertex, V1
2. Find remaining vertex that minimizes angle with
horizontal plane through point. Call edge L
3. Form plane with this edge and horizontal line
perpendicular to L at V1
4. Find remaining vertex that for triangle that
minimizes angle with this plane. Add this
triangle to convex hull, mark edges as
unmatched
5. For each unmatched edge, find remaining vertex
that minimizes angle with the plane of the
edge’s triangle
Convex hull
Convex hull
Convex hull
Convex hull
Convex hull
Convex hull
Convex hull
Bounding Slabs
For better fit bounding polyhedron: use arbitrary
(user-specified) collection of bounding plane-pairs
Is a vertex between each pair?
d2  N  P  d1
Sphere vs. Sphere
Compare distance (p1,p2) to r1+r2
distance(p1,p2)2 to (r1 + r2)2
AABB vs. AABB
AABB vs. AABB
Oriented bounding boxes and arbitrary
polygons
• Separating axis theorem
– http://gamedev.tutsplus.com/tutorials/implement
ation/collision-detection-with-the-separating-axistheorem/
– http://www.sevenson.com.au/actionscript/sat/
– http://www.metanetsoftware.com/technique/tut
orialA.html
Sphere vs. AABB
Sphere vs. AABB – clamping
Sphere vs. AABB – closest point
Collision detection: polyhedra
1. test bounding volumes for overlap
2. test for vertex of one object inside of other object
3. test for edge of one object intersecting face of other object
Collision detection: polyhedra
Intersection = NO
For each vertex, V, of object A
if (V is inside of B) intersection = YES
For each vertex, V, of object B
if (V is inside of A) intersection = YES
A vertex is inside a convex polyhedron if
it’s on the ‘inside’ side of all faces
A vertex is inside a cancave polyhedron if
a semi-infinite ray from the vertex
intersects an odd number of faces
Collision detection: polyhedra
Edge intersection face test
Finds all polyhedral intersections,
but is the most expensive test:
for all faces (i)
for all edges (j)
test face i for intersection with edge j
If vertices of edges are on opposite side of plane of face
Calculate intersection of edge with plane
Determine if that point of intersection is inside the face
Collision response
Collisions: physics review
• Momentum p  mv
• In a closed system, momentum is conserved
p  mv  m'v'
• After a collision, the sum of all momentums is
the same as the sum of all momentum before
the collision
Collision types
Elastic collisions – no loss of kinetic
energy (e.g. deformations, heat)
Kinetic energy
Inelastic collisions – loss of
kinetic energy
1 2
E   mv
2
Elastic collision with stationary object:
horizontal and vertical walls/planes
• For vertical
wall/boundary
– Negate x component of
velocity
– Preserve y component of
velocity
• Ex: v0 = (3,-3) ; v = (-3,-3)
• For horizontal
walls/boundaries
– Preserve x
– Negate y
Elastic collision with stationary object:
angled walls/planes
• Still split velocity vector into
components
– Now with respect to the normal
(n) of the wall
• u = (v * n / n * n) n
– Note: * is dot product
– Vector/direction is parallel to n
– Scalar/magnitude is in opposite
direction of n; (v * n) < 0
• w=v–u
• Reflected velocity:
v’ = w – u
Penalty method
normal
spring
force
Collision response: penalty
Collision response: damped
Damping factor = 0.8
Other object vs. plane ideas
normal
old velocity
distance from plane
new velocity
Elastic collision with movable object
Other object vs. object ideas
v2
v1
Inelastic Collisions
Coefficient of restitution
ratio of velocities before and
after collision
(dampen the resulting velocity)
Objects stick together,
momentum is conserved
ADDITIONAL SLIDES
Collision detection speedup
Particle collision detection loop
ArrayList Particles = new ArrayList();
Particle p;
Particles.Add(p);
…
void HandleAllParticleCollisions(){
for(int i=0; i < Particles.Count; i++){
for(int j =i+1 j < Particles.Count; j++) {
// test Particles i and j for collision
}
}
}
Collision detection speedup
• Two approaches
– Bound the object
– Bound the space the object is contained in
Hierarchical bounding volumes
Approximating polyhedra with spheres for time-critical collision detection, by Philip M. Hubbard
HBV example
HBV example
HBV example
Spatial subdivision – grid
(quadtrees and octrees)
Spatial subdivision – binary space
partitioning
Collision detection: swept volume
Time & relative direction of travel sweeps out a volume
Only tractable in simple cases (e.g. linear translation)
If part of an object is in the volume, it was
intersected by object
Additional issues
• Adding physics for rotation
• Handling multiple collisions
• Resting contact