Comparison of Collision Detection Algorithms

1
Comparison of Collision Detection Algorithms

• Tony Young
• M.Math Candidate
• July 19th, 2004

2
Outline

• Collision Detection Background
• What is collision detection?
• Applications and Importance
• Detection Algorithms
• Bounding Boxes
• Bounding Spheres
• BSP Trees
• Hubbard

3
What is Collision Detection?

• Collision detection is the processing of two
  objects bounds to determine if those bounds
  intersect at any time, t
• Collision detection is a difficult problem to
  solve in constant or linear time
• Collision detection schemes are used in many
  applications

4
Applications and Importance

• Marine, Land and Air navigation
• Detecting if/when collisions between two vehicles
  will take place
• Aiding in avoiding collisions with alerts to
  captains, drivers and pilots

5
Applications and Importance

• Accident Alerts
• Automatically notifying police of collisions at
  intersections, on highways, etc.
• Aids in response time and provides details as to
  the speed of collision, etc.
• Potentially saves lives!

6
Applications and Importance

• Graphics Rendering
• Important for rendering a scene
• We want realistic things to happen

7
Applications and Importance

• Simulation
• Simulations should be as accurate to life as
  possible
• Objects move according to impacts

8
Applications and Importance

• Animation
• In order to properly render animations we must
  know when fabrics are pulled tight against
  bodies, items are resting on tables, etc.
• Lifelike animation requires lifelike modeling of
  collisions, and this requires collision detection

9
Applications and Importance

• Computer Games
• In order to determine when a player is hit, or
  how an object should move in a scene, collisions
  must be detected

10
Applications and Importance

• Overriding themes
• Safety
• Entertainment
• Research
• Three opposites, but both very important to our
  current value system in North America

11
Bounding Boxes

• Place a box around an object
• Box should completely enclose the object and be
  of minimal volume
• Fairly simple to construct
• Test intersections between the boxes to find
  intersections

12
Bounding Boxes

• Each box has 6 faces (planes) in 3D
• Simple algebra to test for intersections between
  planes
• If one of the planes intersects another, the
  objects are said to collide

13
Bounding Boxes

• Example bounding boxes

14
Bounding Boxes

• Space complexity
• Each object must store 8 points representing the
  bounding box
• Therefore, space is O(8) and ?(8)

15
Bounding Boxes

• Time complexity
• Each face of each object must be tested against
  each face of each other object
• Therefore, O((6n)2) O(n2)
• n is the number of objects

16
Bounding Boxes

• Pro
• Very easy to implement
• Very little extra space needed
• Con
• Very coarse detection
• Very slow with many objects in the scene

17
Bounding Spheres

• Similar to bounding boxes, but instead we use
  spheres
• Must decide on a center point for the object
  that minimizes the radius
• Can be tough to find such a sphere that minimizes
  in all directions
• Spheres could leave a lot of extra space around
  the object!

18
Bounding Spheres

• Each sphere has a center point and a radius
• Can build an equation for the circle
• Simple algebra to test for intersection between
  the two circles

19
Bounding Spheres

• Example bounding spheres

20
Bounding Spheres

• Space complexity
• Each object must store 2 values - center and
  radius - to represent the sphere
• Therefore, space is O(2) and ?(2)
• Space is slightly less than bounding boxes

21
Bounding Spheres

• Time complexity
• Each object must test its bounding sphere for
  intersection with each other bounding sphere in
  the scene
• Therefore, O(n2)
• n is the number of objects
• Significantly fewer calculations than bounding
  boxes!

22
Bounding Spheres

• Pro
• Even easier to implement (than bounding boxes)
• Even less space needed (than bounding boxes)
• Con
• Still fairly coarse detection
• Still fairly slow with many objects

23
BSP Trees

• BSP (Binary Space Partitioning) trees are used to
  break a 3D object into pieces for easier
  comparison
• Object is recursively broken into pieces and
  pieces are inserted into the tree
• Intersection between pieces of two objects
  spaces is tested

24
BSP Trees

• We refine our BSP trees by recursively defining
  the children to contain a subset of the objects
  of the parent
• Stop refining on one of a few cases
• Case 1 We have reached a minimum physical size
  for the section (ie one pixel, ten pixels, etc)
• Case 2 We have reached a maximum tree depth (ie
  6 levels, 10 levels, etc)
• Case 3 We have placed each polygon in a leaf
  node
• Etc - Depends on the implementer

25
BSP Trees

• Example BSP Tree

26
BSP Trees

• Example BSP Tree

27
BSP Trees

• Example BSP Tree

28
BSP Trees

• Example BSP Tree

29
BSP Trees

• Collision Detection
• Recursively travel through both BSP trees
  checking if successive levels of the tree
  actually intersect
• If the sections of the trees that are being
  tested have polygons in them
• If inner level of tree, assume that an
  intersection occurs and recurse
• If lowest level of tree, test actual intersection
  of polygons
• If one of the sections of the trees that are
  being tested does not have polygons in it, we can
  surmise that no intersection occurs

30
BSP Trees

• Collision Detection Example

31
BSP Trees

• Collision Detection Example

32
BSP Trees

• Collision Detection Example

33
BSP Trees

• Collision Detection Example

34
BSP Trees

• Collision Detection Example

35
BSP Trees

• Space Complexity
• Each object must store a BSP tree with links to
  children
• Leaf nodes are polygons with geometries as
  integer coordinates
• Therefore, space depends on number of levels of
  tree, h, and number of polygons (assume convex
  triangles - most common), n
• Therefore, space is O(4h 3n) and ?(4h 3n)

36
BSP Trees

• Time Complexity
• Each object must be tested against every other
  object - n2
• If intersection at level 0, must go through the
  tree - O(h)
• Assume all trees of same height
• Depends on number of intersections, m
• Therefore, O(n2 mh) and ?(n2)

37
BSP Trees

• Pros
• Fairly fine grain detection
• Cons
• Complex to implement
• Still fairly slow
• Requires lots of space

38
Hubbard

• Makes use of Sphere Trees and Space-time Bounds
  to iteratively refine its accuracy
• Two phases
• Broad Phase constructs space-time bounds and
  does coarse comparisons
• Narrow Phase run only if broad phase detects a
  collision refines detection to determine if
  there really was a collision

39
Hubbard - Broad Phase

• Constructs space-time bounds
• 4D structure giving conservative estimate of
  where objects might be in the future
• Finds intersections between space-time bounds at
  time ti for objects O1 O2
• Can stop processing until ti arrives

40
Hubbard - Broad Phase

• At ti, checks O1 O2s bounding spheres to
  determine if an intersection occurs
• If yes, refers objects to narrow phase
• If no, recalculate space-time bounds and start
  again

41
Hubbard - Narrow Phase

• Progressively refines intersection test accuracy
• Uses better approximations to O1 and O2 through
  the constructed sphere trees
• Each level of a sphere tree fits object more
  tightly
• Can recursively check for intersections on small
  parts of the tree

42
Hubbard - Narrow Phase

• Allows system to interrupt algorithm after each
  iteration
• System gets as accuracy proportional to amount of
  computing time it can spare
• Narrow phase terminates when
• Case 1 System interrupts current result is
  final
• Case 2 Finds no intersection at a sphere tree
  level
• Case 3 Hits sphere tree leaves Intersection

43
Hubbard - Example

• Start System
• Construct Sphere Trees
• Run scene
• Broad Phase on Frame 1
• Calculates space-time bounds
• Finds intersection between O1 and O2 at ti 5
• Run scene to Frame 5

44
Hubbard - Example

• Broad Phase on Frame 5
• Detects no collision on bounding spheres
• Calculates space-time bounds
• Finds intersection between O2 and O3 at ti 7
• Run scene to Frame 7

45
Hubbard - Example

• Broad Phase on Frame 7
• Detects collision on bounding spheres
• Narrow Phase on Frame 7 for O2 O3
• Detects collision on level 1 spheres
• Detects collision on level 2 spheres
• Detects no collision on level 3 spheres
• Exit case 2

46
Hubbard - Example

• Broad Phase on Frame 8
• Calculates space-time bounds
• Finds intersection between O3 and O4 at ti 10
• Run scene to Frame 10

47
Hubbard - Example

• Broad Phase on Frame 10
• Detects collision on bounding spheres
• Narrow Phase on Frame 10 for O3 and O4
• Detects collision on level 1 spheres
• Detects collision on level 2 spheres
• Detects collision on level 3 spheres
• No more levels - collision detected
• Exit case 3

48
Hubbard - Example

• Broad Phase on Frame 11
• Calculates space-time bounds
• Finds intersection between O4 and O5 at ti 12
• Run scene to Frame 12

49
Hubbard - Example

• Broad Phase on Frame 12
• Detects collision on bounding spheres
• Narrow Phase on Frame 12 for O4 and O5
• Detects collision on level 1 spheres
• Detects collision on level 2 spheres
• Detects collision on level 3 spheres
• Interrupted by system - collision currently
  detected
• Exit case 1

50
Hubbard - Problem!

• Collision may not be present further down the
  tree
• Collision is reported anyway because system
  interrupted without narrow phase completing
• Leads to false positives

51
Hubbard - Space-Time Bounds

• Space-time bounds are 4D structures
• represent objects possible location in 3D over
  time
• System knows
• Objects position - p(x,y,z)
• Objects velocity - v(x,y,z)
• Objects acceleration - a(x,y,z)
• Value, M, such that a(t) M until t tj

52
Hubbard - Space-Time Bounds

• Then, we know that p is subject to the
  inequality p(t) - p(0) v(0)t (M / 2)t2
• Thus, objects position is inside a sphere of
  radius (M / 2)t2 centered at p(0) v(0)t

53
Hubbard - Space-Time Bounds - Example

• Position of p at t 0

54
Hubbard - Space-Time Bounds - Example

• Possible position of p at t 0.1

55
Hubbard - Space-Time Bounds - Example

• Possible position of p at t 0.2

56
Hubbard - Space-Time Bounds - Example

• Possible position of p at 0 t 1

57
Hubbard - Space-Time Bounds - Example

• Possible enclosing hypertrapezoid

58
Hubbard - Space-Time Bounds

• This approximation results in large amounts of
  conservatism
• Hypertrapezoid bounds areas that object could
  never occupy
• If we know that acceleration is limited to a
  certain directional vector, d(t), we can generate
  a cutting plane behind objects position

59
Hubbard - Space-Time Bounds

• Cutting plane
• allows us to reduce the size of the
  hypertrapezoid
• Allows us to make more accurate broad phase
  detections
• Requires application to provide d(t)

60
Hubbard - Space-Time Bounds

• A complete space-time bound, B, requires
• Application provided M
• Application provided d(t)
• Calculated hypertrapezoid - T
• Calculated cutting plane - P

61
Hubbard - Space-Time Bounds - Example

• Possible complete space-time bound

62
Hubbard - Using Bounds

• How do we use space-time bounds?
• Recall If they intersect, we have detected a
  coarse collision
• Intersection of bound B1 and B2 can happen in
  three ways
• (1) A face, f1, of T1 intersects a face, f2, of
  T2

63
Hubbard - Using Bounds

• Intersection of bound B1 and B2 can happen in
  three ways
• (2) A face, f, of a T intersects a cutting plane,
  P, of a T
• Object can never be behind the cutting plane
• Only care about part of f in front of P
• To get in front of P, f must intersect another
  face
• Only care about intersection of two faces

64
Hubbard - Using Bounds

• Intersection of bound B1 and B2 can happen in
  three ways
• (3) A cutting plane, P1, of T1 intersects a
  cutting plane, P2, of T2
• Object can never be behind the cutting plane
• Only care about part of P1 in front of P2 and vs.
• To get in front of P1, a face from T1 must
  intersect a face from T2
• Only care about intersection of two faces

65
Hubbard - Using Bounds

• Reduced three cases of intersection to one that
  we care about
• How do we find intersections?
• Projection
• Subdivision

66
Hubbard - Finding Intersections

• Relies on three axioms (proved in papers, not
  here)
• Each face f of a hypertrapezoid T is normal to
  one of the axis of the coordinate system
• Each face f is included in a face set,Fa f
  f is normal to axis a, a in x, y, z
• Each intersection takes place between two faces
  in the same Fa

67
Hubbard - Finding Intersections

• Algorithm can test each combination in each face
  set

68
Hubbard - Finding Intersections Projection

• Step 1 Project each face in a face set, Fa, onto
  the a-t plane.
• Faces will appear as 2D lines on the plane
• Intersection of these lines is necessary but not
  sufficient for an intersection of two faces

69
Hubbard - Finding Intersections Projection

• Step 2 Find intersections between 2D line
  segments
• Trivial algebra and mathematics
• Keep track of each intersection, I, as a set of
  intersecting faces, and the point on the t plane
  where they intersect

70
Hubbard - Finding Intersections Projection

• Step 3 Check intersection of cube cross-sections
  of the hypertrapezoids that the two faces in I
  belong to at time t
• Trivial algebra and mathematics
• If intersection no longer present, drop faces
• If intersection still present, keep faces

71
Hubbard - Finding Intersections Projection

• Step 4 Determine if point of intersection is
  behind a cutting plane for either hypertrapezoid
• If so, intersection is discarded
• If not, intersection is real and is reported
• Remember We are only interested in the EARLIEST
  intersection!

72
Hubbard - Projection Example
73
Hubbard - Projection Example

• Faces in the 3D plane

74
Hubbard - Projection Example

• Faces projected onto t-z plane

75
Hubbard - Projection Example

• Projections intersect at t1

76
Hubbard - Projection Example

• Cube cross-sections intersect

77
Hubbard - Projection Example

• Intersection below cutting plane

78
Hubbard - Finding Intersections Subdivision

• Recoursively divide hypertrapezoids into 3D cubes
  along the t-axis
• Test for intersections between any pair of cube
  faces in 3D
• If there is an intersection, subdivide the cubes
  and check again
• Aim is to find time t at which intersection takes
  place
• Base case is an application-provided ?t

79
Hubbard - Subdivision Example

• Check first section

80
Hubbard - Subdivision Example

• Intersection subdivide

81
Hubbard - Subdivision Example

• Intersection subdivide again

82
Hubbard - Subdivision Example

• ?t reached with intersection at t1

83
Hubbard - Projection vs. Subdivision

• Projection is more difficult to implement
• Subdivision might suffer from false positives due
  to bad ?t
• Projection executed faster during empirical tests
  and is thus used in the final version of the
  algorithm
• Tests used 200 sets of randomly distributed
  hypertrapezoids of varying parameters (ie
  position, velocity, etc.)

84
Hubbard

• Space-time bounds are nice, but are only half the
  equation
• We need sphere trees for each object in the scene
  in order to run our narrow phase

85
Hubbard - Sphere Trees

• Sphere trees are a constant refinement of a
  bounding sphere for an object
• An object is represented as a set of overlapping
  spheres
• The overlapping spheres are represented as a set
  of tighter overlapping spheres, etc. until we
  reach the applications requested accuracy level

86
Hubbard - Sphere Trees

• Progressively more spheres are used at each level
  of the tree in order to approximate the object
  closer
• The spheres at level i 1 more tightly cover the
  area that the spheres at level i cover
• Spheres are very easy to compare for intersection

87
Hubbard - Sphere Trees - Example

• Level 0 the root

88
Hubbard - Sphere Trees - Example

• Level 1

89
Hubbard - Sphere Trees - Example

• Level 2 etc

90
Hubbard - Sphere Trees

• Accuracy of sphere tree, or tightness of fit,
  is important to ensure that we have proper
  accuracy
• Algorithm could stop narrow phase at any point
• Want to make sure that we have the most accurate
  detection possible to that point

91
Hubbard - Sphere Trees

• Construction of sphere tree is a form of
  multiresolution modeling
• Very complex task
• Tough to automate efficiently
• Many algorithms
• We will look at Medial-Axis Surface method

92
Hubbard - Sphere Trees

• Medial-axis surface
• Corresponds to the skeleton of an object
• Difficult to build for a 3D polyhedron
• Algorithm works backwards
• Covers the object with tightly fitting spheres
  first
• Combine spheres into larger ones at next step
• Sphere tree is constructed bottom-up

93
Hubbard - Sphere Trees

• Start by making the smallest sphere that covers
  an area of the object and touches it at eight
  points
• Repeat until the entire object is enclosed in
  these spheres
• Continue by combining adjacent spheres into
  larger ones
• Stop when we combine all remaining spheres into
  one large sphere

94
Hubbard - Sphere Trees - Example

• Possible first computation of medial-axis surface
  algorithm

95
Hubbard - Problem

• This process takes a HUGE amount of time!
• An object with 626 triangles took 12.4 minutes to
  generate a sphere tree!
• Note that sphere trees are also constructed prior
  to running the scene

96
Hubbard - Putting it all together

• Take scene as input
• Object models
• Values of M and d(t)
• Generate sphere tree for each object
• Calculate first space-time bound
• Calculate hypertrapezoid and cutting plane
• Calculate ti where first intersection takes place
• Start scene and broad/narrow phase testing

97
Hubbard - Example

• Sample scene

98
Hubbard - Example

• Sphere trees

99
Hubbard - Example

• Initial space-time bound

100
Hubbard - Example

• Initial intersection

101
Hubbard - Example

• Initial intersection above cut plane ti5

102
Hubbard - Example

• Run scene to t5
• Recalculate space-time bounds
• Still intersects
• Run narrow phase at t5

103
Hubbard - Example

• Sphere trees intersect at level 0

104
Hubbard - Example

• Sphere trees intersect at level 0

105
Hubbard - Example

• Sphere trees intersect at level 1

106
Hubbard - Example

• Sphere trees intersect at level 2

107
Hubbard - Example

• No levels left - intersection reported
• Could have exited if application interrupted us
• Since we had an intersection at each level, we
  would have reported an intersection
• Could have exited if we found no intersection at
  a lower level
• We had no lower levels to resort to

108
Hubbard - Evaluation

• Tested against Turks method which tests for
  intersections between spheres stored in BSP trees
  (no space-time bounds)
• If detections are found very early in the
  simulation (before 0.25 sec), Hubbard is slower
  than Turk
• Otherwise, Hubbard experiences a detection speed
  boost of approximately 10 times over Turk

109
Hubbard - Evaluation

• Speed-up in over Turks BSP trees
• Mean speedup is
• Level is tree level (their 1 example 0)
• Number is of cases to reach that level

110
Hubbard - Evaluation

• Space Complexity
• Each object has
• One Hypertrapezoid - 4 D 16 points
• One Sphere Tree - 2h links with 2h spheres (2h(2
  points))
• One set of direction and acceleration vectors - 2
  points
• One set of bounding values (M and d(t)) - 2
  values
• Objects structures do not depend on each other
• Therefore, space is O(2h 4h 20) and ?(2h 4h
  20)

111
Hubbard - Evaluation

• Time Complexity
• Broad Phase
• Must compare each face in each set to each other
  face in each set - O(3(2n)2) O(n2) - and -
  ?(1)
• n is the number of objects
• Narrow Phase
• Must compare spheres in the sphere tree for the
  two colliding objects - O(m) - and - ?(1)
• m is the number of levels of sphere tree compared
• Therefore, time is ?(1) and O(n2 m) per run of
  detection algorithm

112
Hubbard - Conclusions

• Algorithm allows average-case real-time collision
  detection
• Faster than Turks algorithm (previously thought
  to be the best)
• May have false positives if application
  interrupts processing too early in narrow phase
  (doesnt get far enough down the tree)
• Constructing sphere trees is slow

113
Summary

• Collision detection is a difficult problem
• Many different strategies
• Most based on object models
• Tough to do in real time
• Collision detection strategies have not
  progressed significantly
• Some small advances in speed and space
• No major new developments
• Most focus is now on collision detection through
  image processing

114
Summary

• Bounding Boxes
• Space but not time efficient
• Very inaccurate detection
• Not real-time
• Bounding Spheres
• Space but not time efficient
• Relatively inaccurate detection
• Not real-time

115
Summary

• BSP Trees
• Inefficient in time and space
• Quite accurate detection
• Not real-time
• Hubbard
• Relatively efficient in time but not space
• Highly accurate detection
• Not real-time (but can be close)

116
Summary

• The clear winner depends on the application
• Hubbard performs best for most real world
  applications where objects are known ahead of
  time (ie games, animation, ATC, etc.)
• BSP trees are good for objects that are not known
  ahead of time (ie auto collision
• Bounding boxes / spheres are good for objects of
  that approximate shape, or for very fast
  detection (ie primitive games, primitive scene
  animation)

117
Questions?