COLLISION DETECTION

来源:http://www.cs.brown.edu/courses/gs007/lect/sim/web/murat.html

COLLISION DETECTION

Importance

Why is collision detection slow?

Explosive Growth

Using the formula: Number of collision tests = (n² -n)/2

Objects Collision Tests 2 1 3 3 4 6 . . . . . . 20 190

O(n²)

Eliminating Collision Tests

Redundant Tests
Game Rules

Eleminations based on spatial positioning such as axis sorting and the sector method

Axis Sorting

Sprite Number 		X-Coordinate		Sprite Width
        1			    10 			    10
        2			    15			    5
        3 			    18			    8
        4 			    40			    10
        5			    45			    10

Sector Method

Collision Testing

Bounding Based
Pixel Based

To find more detailed information on these just click here.

Two collision-detection algorithms that we are going to discuss

I-COLLIDE

Impulse-Based Dynamic Simulation

I-COLLIDE- An incremental algorithm for collision detection between solid models.

I collide is based on temporal and geometric coherence
- What is temporal and geometric coherence?
  - Property that the state of the application does not change significantly between successive time steps or simulation frames.
- By exploiting coherence we are able to trim down the number of pairwise object and feature tests involved in each iteration.
- For n objects,the worst case running time for any collision detection algorithm is O(n²) this is also true for I-collide.
- However, running time of I-Collide for n objects is O(n+m) where m is the number of objects very close to each other.

Two objects are very close if their axis aligned bounding boxes overlap.

What are bounding boxes?

Fixed-Size Bounding Cubes:
- We compute the size of the fixed cube to be large enough to contain the object at any orientation ?
- The cube is defined by a center and radius.
- Easy to recompute as the position changes.
- Well suited for dynamic enviroments. Works well with objects which are nearly spherical.
- At each time step the cube is recomputed as follows:
  - 1. Transform the center by using one vector matrix multiplication.
  - 2. Compute the min and max x , y, z coordinates by subtracting and adding the radius from the coordinates of the center.
  - step 1 is only one vector matrix multiplication
  - step 2 is just 3 additions and 3 subtructions
e.g.
Dynamically Rectangular Bounding Boxes:
- We compute the size of the rectangular bounding box to be the thightest axis aligned box contain the object at a particular orientation.
- It is defined by its min and max x, y and z coordinates (up to 6 of its vertices).As an object moves, its minima and maxima is recalculated
- For oblong objects rectangular objects fit better than cubes resulting in fever overlaps.
- This is an advantage as long as only few objects ore moving.
  e.g.

Sweep and Prune

Sorting the bounding boxes surrunding the objects is the key to the sweep and prune approach.

It is not intuitively obvious how to sort bounding boxes in 3 space.

One way is dimension reduction approach.

First thing we do is to project each 3-dimensional bounding box onto the x,y and z axes.
We are interested in overlaps. Because a pair of bounding boxes can overlap if and only if their intervals overlap in all three dimensions.
We construct 3 lists, one for each dimension.
Each list contains the value of the end-points of the intervals corresponding to that dimension.
By sorting these lists, we can determine which intervals overlap.
In general such a sort will take O(n log n) time However we can reduce this time if we keep the sorted lists from the previous frame, changing only the values of the interval endpoints.
Since there will be relatively small movements between frames the lists will be nearly sorted so we can sort in expected O(n) time using Insertion Sort.

Two- Dimensional Intersection Tests
- Project each 3-dimesional axis-aligned bounding box onto any of the two of the x-y, y-z, x-z planes.
- Each of these projections are rectangles in 2 space so there are fewer overlaps of these 2-D rectangles than the 1-D intervals used by the Sweep and Prune Technique.
- In cases where projection on the one-dimension causes densly clustered intervals the two dimensiona technique is more efficient.
Other Alternatives:
- Binary Space Partitioning (BSP trees), octrees, etc..
- Several practical and efficient algorithms are based on uniform space division.

This page is created by Murat Gorguner

IMPULSED BASED SIMULATION

The two fundamental requirements you want in dynamic simulation:

physical accuracy
computational efficiency - can it run in real time

Impulsed based simulation attempts to fulfill these two requirements

Constraint based vs. impulsed based simulation

dealing with contact

In constraint based simulation:

Example - ball rolling along a table top

-force which table exerts on ball is a constraint force that doesn't do work on the ball but exerts a non-penetration constaint
-force isn't modeled explicit but accounted for by a constraint on the ball - one of the ball`s coordinates is held constant
-problem - constaints may change over time, e.g. ball rolls off the table, hits an object on the table
- -keeping track of the changing constraints in order to calculate the correct motion of the ball can get complicated
-also, impacts create impulses, not constraint forces and must be handled separately

In impulsed based simulation

Example - ball resting on table top

-no constraints are placed on moving objects
=7F
-unification of all types of contact under a single model
- -model used for collisions can be used for instances where an object is rolling or resting on another object
- -not necessary to classify different contact types or deal with them in different ways
-in the example, ball is experiencing many tiny collisions with the table - microcollisions
Does impulsed based simulation result in physically accurate simulations?
Yes, microcollision contact produces correct behavior
Is it fast enough for simulation purposes?
Yes, the large number of collisions which must be calculated does not prohibit real-time simulation

Procedure for implementing impulsed based simulation

First, you assume objects travel in ballistic trajectories when not colliding with anything

For each object, a bounding box is created to enclose the path of an object over a time interval, this is done at the beginning of each frame -a good interval is the frame rate =3D 1/30 seconds

Intersections between the boxes are found, calculated to take O(n(1 + log R)) time where R is ratio of largest to smallest box size

If two boxes don't intersect, objects won't collide in the next frame so no distance or time of impact calcuations have to be done

If they do, the Lin-Canny closest features algorithm is used - same one as in I_COLLIDE -the shortest possible time to collision is calclulated

Each pair is inserted in a heap sorted by time of collision, e.g. pair that= =20 will collide first will be at the top

Time step is inceremented until the time of collision of the top pair

L in-Canny algorithm is done again to find distance between the two objects - collision when distance falls below an epsilon which is at least 3 orders of magnitude smaller than the dimensions of the objects

if collision, do collision resolution, calculate new bounding volumes= =20 for the objects, intersect =09 these new boxes with the others and update the heap accordingly

Drawbacks to this detection system:

Since ballistic trajectory is assumed you can't have any forces all of a=20 sudden affect an =09 object's trajectory - no user interface possible after the initial forces

This is OK for a pool game but not for most other games

Solution:=7F Calculate bounding box that will encompass the maximum displacement an=20 object =09 can go over the time interval

Consequences: More collision detection needed since boxes may be bigger and a it's=20 possible most =09 of the intersecting volumes will produce no collisions when thought was=20 expected =09 since the position of the object in the box varies on the forces enacted

But User Interaction can happen!

Computing collision impulses

When two bodies collide, an impulse must be applied to a body so there is no= =20 interpenetration; the impulse applied to the other body is the negative of the impulse

Once impulse is knowm, you can compute the linear velocity for center of=20 mass and angular velocity and algorith can continune

You don't want to assume frictionless collisions or perfectly elastic=20 collisions, we want to model the real world, unless you're in space

3 assumptions for collisions:

1) Infinitesimal collision time

- The duration of a collision is= =20 negligible compared to the time over which simulated objects move.

Therefore

a)the configurations of two objects may be taken as constant over the= =20 entire collision - even in simulations, it's just overkill to calculate the deformity and=20 rebounding of an object during a collision

b)the effect of one object on another can be described as an impulse which= =20 gives rise to instantaneous change in linear and angular velocities of an object

2) Poisson's hypothesis

P_total =3D (1 + e) * P_max_compression

e =3D constant between 0 and 1, dependent on object's material, called= =20 coefficient of restitution

P_total =3D magnitude of normal component of the impulse done by one=20 object onto the other overthe entire collision

=09 P_max =3D magnitude of normal component of the impulse done by one object= onto the other up to the point of maximum compression

if e =3D 1, collision is totally elastic

if e =3D 0, collision is totally plastic, objects stick together afer= collision

P_max_compression is easy to characterize, it's the point at which the= normal component of the relative contact velocity vanishes.

3)Coulomb friction

u =3D contact velocity of object 1 realtive to object 2

u_t =3D tangential component of u

u_^t =3D unit vector in direction of u_t

f_n =3D normal component of force exerted by object 2 on object= 1

f_t =3D tangentialcomponent of force exerted by object 2 on= object 1

m =3D coefficient of friction

if u_t !=3D 0 ----> f_t =3D -m * abs(f_n) * u_^t

if u_t =3D 0c ----> abs(f_t) <=3D m * abs(f_n)

COLLISION DETECTION