Comparison of Collision Detection Algorithms - PowerPoint PPT Presentation

Loading...

PPT – Comparison of Collision Detection Algorithms PowerPoint presentation | free to download - id: 69cb8a-YThlN



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Comparison of Collision Detection Algorithms

Description:

Comparison of Collision Detection Algorithms Tony Young M.Math Candidate July 19th, 2004 – PowerPoint PPT presentation

Number of Views:7
Avg rating:3.0/5.0
Slides: 118
Provided by: JackA152
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: 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?
About PowerShow.com