This preview shows page 1. Sign up to view the full content.
Unformatted text preview: Fast Proximity Queries for Fast Proximity Queries for Interactive Walkthroughs
Ming C. Lin
University of North Carolina at Chapel Hill
http://www.cs.unc.edu/~geom/collide.html
Presented by Dave Luebke for CS 551/6512 Proximity Queries
Proximity Queries
Collision • A procedure to compute the geometric contact (and distance) between objects. Theme
Theme
• Use of coherence, locality, hierarchy
Use coherence,
and incremental computations
incremental computations t=0
t=1 Other Applications
Other Applications
• Rapid Prototyping tolerance verification
• Dynamic simulation contact force calculation
• Computer Animation motion control
• Motion Planning distance computation
• Haptic Rendering restoring force computation • SimulationBased Design interference detection Goals
Goals
• Efficiency – realtime (interactive) for pairwise & nbody • Accuracy
– exact, not approximation
• Practical
– should work on “realworld” models
– relatively easy to implement
– general yet robust Problem Domain Problem Domain Specifications • Model Representations – polyhedra (convex vs. nonconvex vs. soups)
– CSG, Implicit Rep, Parametric Rep • Type of Queries
–
–
–
– collision detection
distance computation
penetration depth
estimated time to collision • Simulation Environments
–
–
– pairwise vs. nbody
static vs. dynamic
rigid vs. deformable Problem Complexity
Problem Complexity
Given an environment consisted of m objects and each has no more than n polygons, the problem polygons, the problem has the following complexity using bruteforce methods:
• NBody: O(m2)
• Pairwise: O(n2) Organization
Organization
• MultiBody Environments
– Sweep & Prune
– Scheduling Scheme • Pairwise Proximity Queries
– Convex Objects (Lin&Canny, SWIFT)
– General Models (OBBTree, SSV) • Data Management System Architecture
System Architecture
Transform Overlap
Sweep & Prune Exact
Collision
Detection Simulation Parameters Analysis &
Response Collision Sweep and Prune
Sweep and Prune
• Compute the axisaligned bounding box (fixed vs. dynamic) for each object
• Dimension Reduction by projecting boxes onto each x, y, z axis
• Sort the endpoints and find overlapping intervals
• Possible collision only if projected intervals overlap in all 3 dimensions Dimension Reduction
Dimension Reduction
T=1 e3
e2
b3
e1
b2
b1 b1 b2 e1 e2 e3 b3 T=2 b1 b2 e1 e2 b3 e3 e2
e1
b2
e3
b1
b3 Dimension Reduction
Dimension Reduction
T=1
b1 b2 e1 e2 b3 e3 Xaxis b1 b2 e1 b3 e2 e3 Yaxis b1 b2 e1 e2 b3 e3 Xaxis b3 b1 e3 b2 e1 e2 Yaxis T=2 T=1
1
2
3 1 2 3 T=2
1 XY
Y 2
3 1 2 3 XY Y Updating Bounding Boxes
Updating Bounding Boxes
• Coherence (greedy walk) • Convexity properties (geometric properties of convex polytopes)
• Nearly constant time, if the motion is relatively “small” Use of Sorting Methods
Use of Sorting Methods
• Initial sort quick sort runs in O(m log m)
just as in any ordinary situation
just as in any ordinary situation
• Updating insertion sort runs in O(m) due due to coherence. We sort an almost sorted list from last stimulation step. In fact, we look for “swap” of positions in all 3 dimension. Scheduling Scheme
Scheduling Scheme
• When the velocity and acceleration of all objects are known, use the scheduling scheme to prioritize “critical events” to be processed (using heap)
– Each object pair is tagged with the estimated time to next collision. – All object pairs are sorted accordingly. – The heap is updated when a collision occurs. Deriving Bounds
Deriving Bounds
• amax: an upper bound on relative acceleration between an any two points on any pair of objects. • alin: relative absolute linear
∀ α: relative rotational accelerations
∀ ω: relative rotational velocities
• r: vector difference btw CoM of two bodies
vector difference btw CoM of two bodies
• d: initial separation for two given objects
initial separation for two given objects
amax =  alin + α x r + ω x ω x r 
vi =  vllin + ω x r 
in Bounding Time to Collision
Bounding Time to Collision
• Given the bound on maximum relative acceleration (including rotational and linear) amax and initial relative velocity (including rotational & linear) vi
with separation d between two objects, with separation 1/2
tc = [ (vi2 + 2 amax d ) 1/2  vi ] / amax
max Basic Steps
Basic Steps
• Maintain a queue of all object pairs sorted by approximated time to collision
• At each step, only update the closest feature pair at the head of priority queue (as a heap)
• If collision occurs, handle collision
• Recompute timetocollision for the affected feature pairs and reinsert them into the queue Organization
Organization
• Literature Survey
• MultiBody Environments
– Sweep & Prune
– Scheduling Scheme • Pairwise Proximity Queries
– Convex Objects (Lin&Canny, SWIFT)
– General Models (OBBTree, SSV) • Data Management Tracking Closest Features
Tracking Closest Features v • Lin & Canny [1991]: expected O(1) time Voronoi Regions
Voronoi Regions
• Given a collection of geometric primitives, it is a subdivision of space into cells such that all points in a cell are closer to one primitive than to any other
Voronoi
Site
Voronoi
Region Closest Feature Tracking Closest Feature Tracking Using Voronoi Regions Basic Algorithm
Basic Algorithm
• Given one feature from each polyhedron, find the nearest points of the two features. • If each nearest point is in the Voronoi region of the other feature, closest features have been found.
• Else, walk to one or both of their neighbors or some other feature. Running Time Analysis
Running Time Analysis
• Distance strictly decreases with each change of feature pair, and no pair of features can be selected twice.
• Convergence to closest pair typically much better for dynamic environments:
– O(1) achievable in simulations with coherence
– Closer to sublinear time performance even without coherence ICollide Collision Detection ICollide Collision Detection System
• Routines:
– Nbody overlap tests (sweep and prune)
– Distance calculation btwn convex polytopes • Public domain system
• 2500+ researchers have ftp’ed the code
• A mailing list of many hundreds of users ICollide System Demonstrations
ICollide System Demonstrations
• Architectural Walkthrough
• Dynamic Simulator (Impulse)
• MultiBody Simulators Architectural Walkthrough
Architectural Walkthrough System Demonstration
System Demonstration Video Penetration Detection
Penetration Detection Accelerated Proximity Queries based Accelerated Proximity Queries based on MultiLevel Marching
• Improved closest featuretracking based on Voronoi regions
• Use of normal tables to jump start and avoid local minima problem
• Take advantages of levelofdetails (multi
resolution) representations Implementation: SWIFT
Implementation: SWIFT
• Progressive Refinement Framework
• Faster (2x to 10x ) than any public domain packages for convex objects • Insensitive to level of motion coherence
• Will be available at:
http://www.cs.unc.edu/~geom/SWIFT Motivation
Motivatio
Parallel close
Parallel
proximity:
proximity:
piston against
piston
combustion
combustion
chamber wall
chamber
Engine model courtesy of Engineering Animation Inc Motivation Model Courtesy of ABB Engineering, Inc.
A Coalfired Powerplant Model: 15,432,126 triangles BVHBased Collision BVHBased Collision Detection
• Model Hierarchy: – each node has a simple volume that bounds a set of triangles – children contain volumes that each bound a different portion of the parent’s triangles – The leaves of the hierarchy usually contain individual triangles • A binary bounding volume hierarchy: BVHBased Collision BVHBased Collision Detection Higher Order Bounding Higher Order Bounding Volume Hierarchies • OBBTree: Tree of Oriented Bounding Boxes (OBBs)
• SSV: Tree of Swept Sphere Volumes OBBTREES: Organization
OBBTREES: Organization
•
•
•
• Building an OBBTree
Tree Traversal
OBB Overlap Test
Performance Building an OBB Tree Recursive topdown construction:
partition and refit Building an OBB Tree Given some polygons,
consider their vertices... Building an OBB Tree
Project onto the line
Consider variance of
distribution on the line Building an OBB Tree Given by eigenvectors
of covariance matrix
(summarizing the 1st
& 2nd order statistics)
of coordinates
of original points Building an OBB Tree Choose bounding box
oriented this way Building an OBB Tree
… and sample them uniformly Building an OBB Tree: Building an OBB Tree: Summary
OBB Fitting algorithm:
•
•
•
•
• Statisticsbased
Use of convex hull
Uniform sampling distributions
O(n log n) fitting time for single BV
O(n log2 n) fitting time for entire tree OBBTREES: Organization
OBBTREES: Organization
•
•
•
• Building an OBBTree
Tree Traversal
OBB Overlap Test
Performance Tree Traversal
Tree Traversal
Disjoint bounding volumes:
No possible collision Tree Traversal
Overlapping bounding volumes:
Overlapping
• split one box into children
split
• test children against other box
test Tree Traversal
Tree Traversal
First child: no overlap Tree Traversal
Second child overlaps:
Second
• split larger box
split
• continue tests
continue Tree Traversal
Tree Traversal Tree Traversal
Tree Traversal Tree Traversal
Tree Traversal
Hierarchy of tests OBBTREES: Organization
OBBTREES: Organization
•
•
•
• Building an OBBTree
Tree Traversal
OBB Overlap Test
Performance Separating Axis Theorem
Separating Separating Axis Theorem
Separating Axis Theorem
Two polytopes A and B are disjoint iff there
exists a separating axis which is:
perpendicular to a face from either or
perpedicular to an edge from each Implications of Theorem
Implications of Theorem
Given two generic polytopes, each with E edges and F faces, number of candidate axes to test is: 2F + E2
OBBs have only E = 3 distinct edge directions, and only F = 3 distinct face normals. OBBs need at most 15 axis tests.
Because edge directions and normals each form orthogonal frames, the axis tests are rather simple. OBB Overlap Test
OBB Overlap Test
L
ha s
hb L is a separating axis iff: s > ha+hb OBB Overlap Test
OBB Overlap Test
• Project boxes onto axis. If intervals don’t overlap, it is a separating axis.
• A separating axis exists if and only if boxes are disjoint.
• 2D OBBs: 4 axes to test
• 3D OBBs: 15 axes to test OBB Overlap Test
OBB Overlap Test
• Typical axis test for 3space. s = fabs(T2 * R11  T1 * R21); ha = a1 * Rf21 + a2 * Rf11; hb = b0 * Rf02 + b2 * Rf00; if (s > (ha + hb)) return 0;
• Up to 15 tests required. OBB Overlap Test
OBB Overlap Test
• Strengths of this overlap test: – 80 to 234 arithmetic operations per boxoverlap test
– No special cases for parallel/coincident faces, edges, or vertices
– No special cases for degenerate boxes
– No conditioning problems
– Good candidate for microcoding OBB Overlap Test: OBB Overlap Test: SIMD Implementation
[Jointly with Intel]
• Decompose into 5 sets of axis tests – Each set implemented using Katmai SIMD instruction sets
– About 2.5 times speedup in practice OBBTREES: Organization
OBBTREES: Organization
•
•
•
• Building an OBBTree
Tree Traversal
OBB Overlap Test
Performance AABB’s vs. OBB’s
AABB’s vs. OBB’s Approximation
of a Torus Dynamic Simulation
Dynamic Simulation Interactive Collision Detection on 2 complex Pipelines: 140K Engineering Animation
Engineering Animation SimulationBased Design
SimulationBased Design System Demonstration
System Demonstration Video Implementation: RAPID
Implementation: RAPID
• Available at: http://www.cs.unc.edu/~geom/OBB
• Part of VCOLLIDE: http://www.cs.unc.edu/~geom/V_COLLIDE
• More than 3000 users have ftp’ed the code
• Used for virtual prototyping, dynamic simulation, robotics and computer animation Technology Transfer
Technology Transfer
• Virtual Protptyping & VEs: Division, MSC Working Knowledge, Prosolvia, Ford, AmandaSoft, LockheedMartin
• Computer Animation: Jack/Transom Tech.
• Medical Applications: ADAC Lab
• Interactive Gaming: Intel, OZ.com, Blaxxun etc. Swept Sphere Volumes
Swept Sphere Volumes PSS LSS RSS Swept Sphere Volumes Swept Sphere Volumes (Stopes) PSS LSS RSS SSV Fitting
SSV Fitting
• Use OBB’s code based upon Principle Component Analysis
• For PSS, use the largest dimension as the radius
• For LSS, use the two largest dimensions as the length and radius
• For RSS, use all three dimensions Overlap Test
Overlap Test
• One routine that can perform overlap tests between all possible combination of CORE primitives of SSV(s).
• The routine is a specialized test based on Voronoi regions and OBB overlap test.
• It is faster than GJK. Hybrid BVH’s based on SSV
Hybrid BVH’s based on SSV
• Use a simpler BV when it prunes search equally well benefit from lower cost of BV overlap tests
• Overlap test (based on LinCanny & OBB overlap test) between all pairs of BV’s in a BV family is unified
• Complications – deciding which BV to use either dynamically or statically PQP: Implementation
PQP: Implementation
• Library written in C++
• Good for any proximity query
• 520x speedup in distance computation over prior methods
• Available at http://www.cs.unc.edu/~geom/SSV/ PQP: Technology Transfer
PQP: Technology Transfer
• Released in July’99
• More than 250 active users
• Strong interest from Sony
• Optimized for PS2 applications: only 12 routines need optimization Organization
Organization
• MultiBody Environments
– Sweep & Prune
– Scheduling Scheme • Pairwise Proximity Queries
– Convex Objects (Lin&Canny, SWIFT)
– General Models (OBBTree, SSV) • Data Management Processing Large Geometric Databases for Massive Models
Encode the proximity relationship with “overlap graphs” to
partition massive 3D dataset into smaller, manageable datasets
Localized Subgraphs Database Scene
Graph Overlap
Graph System Architecture
System Architecture Partition
& Refine
Graphs Proximity
Queries Localized Subgraphs
Localized Subgraphs
• Reduce frequency of disk accessing • Runtime ordering & traversal
• Localize region of contacts
• Allow modification on the fly
• Prefetch geometry 2D Objects
2D Objects • A simple environment consisting of polygons Object Bounding Boxes
Object Bounding Boxes • Each object is bounded by a AABB. Object Nodes
Object Nodes • Each node corresponds to an object. Overlap Graph
Overlap Graph • Each edge corresponds to a potential overlap & each node has a weight proportional to object memory requirement (polygon # & hierarchies) Computing Connected Computing Connected Components
• Identify cacheable components
• Object decomposition
• Find highvalence nodes
• Multilevel graph partitioning
…Repeat on the resulting cut graph till decomposing the overlap graph into localized subgraphs, such that the weight of each subgraph < memory cache size Algorithmic Choices
Algorithmic Choices
• Types of Bounding Volumes (e.g. spheres, AABBS, OBBs, etc.)
• Onthefly Hierarchy Construction & Lazy Evaluation IMMPACT: Implementation
IMMPACT: Implementation
• Written in C++ & OpenGL
• Built on top of PQP (UNCCH)
• Use of METIS (University of Minnesota)
• Realtime interaction with CAD models
[Eurographics’99] IMMPACT: Demonstration
IMMPACT: Demonstration Realtime Interaction with PowerPlant (15 million triangles) Technology Transfer & Feedback
Technology Transfer & Feedback
• 7 Collision Detection & Proximity Systems
• More than 4500 downloads
• More than 40 commercial licenses
• The Collide Inc. handles licensing
• Useful feedback from our users Collaborators
Collaborators
•
•
•
•
•
•
•
•
•
• Dinesh Manocha John Canny (Berkeley)
Jonathan Cohen (Johns Hopkins)
Stephen Ehmann
Stefan Gottschalk (NVidia)
Eric Larsen (Sony R&D America)
Brian Mirtich (MERL)
Amol Pattekar (Yahoo)
Krish Ponamgi
Andy Wilson •
• Intel MGL Research Group
Sony PS2 R&D Group Acknowledgments
Acknowledgments
• Army Research Office
• Honda
• Intel
• National Science Foundation
• Office of Naval Research
• Sloan Foundation ...
View
Full
Document
 Summer '11
 Lubke
 Computer Graphics

Click to edit the document details