fast proximity queries for interactive walkthroughs ming c. lin university of north carolina at...

Fast Proximity Queries for Fast Proximity Queries for Interactive WalkthroughsInteractive Walkthroughs

Ming C. LinMing C. LinUniversity of North Carolina at Chapel HillUniversity of North Carolina at Chapel Hillhttp://www.cs.unc.edu/~geom/collide.htmlhttp://www.cs.unc.edu/~geom/collide.html

Presented by Dave Luebke for CS 551/651-2Presented by Dave Luebke for CS 551/651-2

Proximity QueriesProximity Queries

• A procedure to compute the A procedure to compute the geometric contact (and distance) geometric contact (and distance) between objects.between objects.

Collision

ThemeTheme

Use of Use of coherence, locality, hierarchycoherence, locality, hierarchy and and incrementalincremental computationscomputations

t = 0

t = 1

Other ApplicationsOther Applications

• Rapid PrototypingRapid Prototyping -- tolerance verification-- tolerance verification

• Dynamic simulationDynamic simulation -- contact force calculation-- contact force calculation

• Computer AnimationComputer Animation ---- motion controlmotion control

• Motion PlanningMotion Planning -- distance computation-- distance computation

• Haptic RenderingHaptic Rendering -- restoring force computation-- restoring force computation

• Simulation-Based DesignSimulation-Based Design -- interference detection -- interference detection

GoalsGoals

• Efficiency Efficiency – real-time (interactive) for pairwise & n-bodyreal-time (interactive) for pairwise & n-body

• AccuracyAccuracy– exact, not approximationexact, not approximation

• PracticalPractical– should work on “should work on “real-worldreal-world” models” models– relatively easy to implementrelatively easy to implement– general yet general yet robustrobust

Problem Domain Problem Domain SpecificationsSpecifications

• Model RepresentationsModel Representations– polyhedra (convex vs. non-convex vs. soups)polyhedra (convex vs. non-convex vs. soups)– CSG, Implicit Rep, Parametric RepCSG, Implicit Rep, Parametric Rep

• Type of QueriesType of Queries– collision detectioncollision detection– distance computationdistance computation– penetration depthpenetration depth– estimated time to collisionestimated time to collision

• Simulation EnvironmentsSimulation Environments– pairwise vs. n-bodypairwise vs. n-body– static vs. dynamicstatic vs. dynamic– rigid vs. deformablerigid vs. deformable

Problem ComplexityProblem Complexity

Given an environment consisted of Given an environment consisted of mm objects and each has no more than objects and each has no more than n n polygons, the problem has the following polygons, the problem has the following complexity using brute-force methods:complexity using brute-force methods:

•N-Body: N-Body: O(mO(m22))

•Pairwise: Pairwise: O(nO(n22))

OrganizationOrganization

• Multi-Body EnvironmentsMulti-Body Environments– Sweep & PruneSweep & Prune

– Scheduling SchemeScheduling Scheme

• Pairwise Proximity QueriesPairwise Proximity Queries– Convex Objects (Lin&Canny, SWIFT)Convex Objects (Lin&Canny, SWIFT)

– General Models (OBBTree, SSV)General Models (OBBTree, SSV)

• Data ManagementData Management

System ArchitectureSystem Architecture

Analysis & Response

Sweep & Prune

SimulationExact CollisionDetection

Collision

Transform Overlap

Parameters

Sweep and PruneSweep and Prune

• Compute the axis-aligned bounding box Compute the axis-aligned bounding box (fixed vs. dynamic) for each object(fixed vs. dynamic) for each object

• Dimension Reduction by projecting boxes Dimension Reduction by projecting boxes onto each onto each x, y, zx, y, z- axis- axis

• Sort the endpoints and find overlapping Sort the endpoints and find overlapping intervalsintervals

• Possible collision -- only if projected Possible collision -- only if projected intervals overlap in all 3 dimensions intervals overlap in all 3 dimensions

Dimension ReductionDimension Reduction

b1 b2 e1 e2 b3 e3

b1

b2

e1

b3

e2

e3T = 1

b1 b2 e1e2 b3 e3

b3

b1

e3

b2

e1

e2

T = 2

Dimension ReductionDimension Reduction

1 2 31

2

3

1 2 31

2

3

T = 1 T = 2

X Y

Y

X Y Y

T = 2

e3

b1 e1b2 b3e2 e3

b1 b2 e1 e2b3

b1 b2 e1 e2 b3 e3

b3 b1 e3 b2 e1 e2

X-axis

X-axis

Y-axis

Y-axis

T = 1

Updating Bounding Updating Bounding BoxesBoxes

• CoherenceCoherence (greedy walk)(greedy walk)

• Convexity properties Convexity properties (geometric (geometric properties of convex polytopes)properties of convex polytopes)

• Nearly constant timeNearly constant time, if the , if the motion is relatively “small”motion is relatively “small”

Use of Sorting MethodsUse of Sorting Methods

• Initial sortInitial sort -- quick sort runs in -- quick sort runs in O(m log O(m log m)m) just as in any ordinary situationjust as in any ordinary situation

• UpdatingUpdating -- insertion sort runs in -- insertion sort runs in O(m)O(m) due to coherence. We sort an due to coherence. We sort an almost sorted list from last almost sorted list from last stimulation step. In fact, we look for stimulation step. In fact, we look for “swap” of positions in all 3 “swap” of positions in all 3 dimension.dimension.

Scheduling SchemeScheduling Scheme

• When the velocity and acceleration of When the velocity and acceleration of all objects are known, use the all objects are known, use the scheduling schemescheduling scheme to prioritize “critical to prioritize “critical events” to be processed (using heap)events” to be processed (using heap)

– Each object pair is tagged with the Each object pair is tagged with the estimated time to next collision. estimated time to next collision.

– All object pairs are sorted accordingly. All object pairs are sorted accordingly. – The heap is updated when a collision The heap is updated when a collision

occurs.occurs.

Deriving BoundsDeriving Bounds

• aamaxmax:: an upper bound on relative acceleration an upper bound on relative acceleration between any two between any two points points on any pair of objects. on any pair of objects.

• aalinlin: relative absolute linear: relative absolute linear : relative rotational accelerations: relative rotational accelerations : relative rotational velocities: relative rotational velocities• rr: : vector difference btw CoM of two bodiesvector difference btw CoM of two bodies • dd: : initial separation for two given objectsinitial separation for two given objects

aamaxmax = | a = | alinlin + + xx r + r + xx x x r |r |

vvii = | v = | vlin lin + + xx r | r |

Bounding Time to Bounding Time to CollisionCollision

• Given the bound on maximum relative Given the bound on maximum relative acceleration (including rotational and acceleration (including rotational and linear) linear) aamaxmax and initial relative velocity and initial relative velocity (including rotational & linear) (including rotational & linear) vvii with with separation separation dd between two objects, between two objects,

ttcc = [ ( = [ (vvii22 + 2 + 2 aamax max dd ) ) 1/21/2 - - vvii ] ] // aamaxmax

Basic StepsBasic Steps

• Maintain a queue of all object pairs sorted by Maintain a queue of all object pairs sorted by approximated time to collisionapproximated time to collision

• At each step, only update the closest feature At each step, only update the closest feature pair at the head of priority queue (as a heap)pair at the head of priority queue (as a heap)

• If collision occurs, handle collisionIf collision occurs, handle collision

• Re-compute time-to-collision for the affected Re-compute time-to-collision for the affected feature pairs and reinsert them into the feature pairs and reinsert them into the queuequeue


• Literature SurveyLiterature Survey






Tracking Closest Tracking Closest FeaturesFeatures

• Lin & Canny [1991]: expected Lin & Canny [1991]: expected O(1)O(1) time time performance, independent of complexityperformance, independent of complexity

v

Voronoi RegionsVoronoi Regions

• Given a collection of geometric Given a collection of geometric primitives, it is a subdivision of space primitives, it is a subdivision of space into cells such that all points in a cell into cells such that all points in a cell are are closercloser to one primitive than to any to one primitive than to any otherother

Voronoi Site

Voronoi Region

Closest Feature Closest Feature Tracking Using Voronoi Tracking Using Voronoi RegionsRegions

Basic AlgorithmBasic Algorithm

• Given one feature from each polyhedron, Given one feature from each polyhedron, find the nearest points of the two features. find the nearest points of the two features.

• If each nearest point is in the Voronoi If each nearest point is in the Voronoi region of the other feature, closest region of the other feature, closest features have been found.features have been found.

• Else, walk to one or both of their neighbors Else, walk to one or both of their neighbors or some other feature.or some other feature.

Running Time AnalysisRunning Time Analysis

• Distance strictly decreases with each Distance strictly decreases with each change of feature pair, and no pair of change of feature pair, and no pair of features can be selected twice.features can be selected twice.

• Convergence to closest pair typically Convergence to closest pair typically much better for dynamic environments:much better for dynamic environments:– O(1) achievable in simulations with O(1) achievable in simulations with

coherencecoherence– Closer to sub-linear time performance Closer to sub-linear time performance

even without coherenceeven without coherence

I-Collide Collision I-Collide Collision Detection SystemDetection System

• Routines:Routines:

– N-body overlap tests (sweep and prune)N-body overlap tests (sweep and prune)

– Distance calculation btwn convex polytopesDistance calculation btwn convex polytopes

• Public domain systemPublic domain system

• 2500+ researchers have ftp’ed the code2500+ researchers have ftp’ed the code

• A mailing list of many hundreds of usersA mailing list of many hundreds of users

I-Collide System I-Collide System DemonstrationsDemonstrations

• Architectural WalkthroughArchitectural Walkthrough

• Dynamic Simulator (Impulse)Dynamic Simulator (Impulse)

• Multi-Body SimulatorsMulti-Body Simulators

Architectural Architectural WalkthroughWalkthrough

System DemonstrationSystem Demonstration

VideoVideo

Penetration DetectionPenetration Detection

Accelerated Proximity Queries Accelerated Proximity Queries based on Multi-Level Marchingbased on Multi-Level Marching

• Improved closest feature-tracking Improved closest feature-tracking based on Voronoi regionsbased on Voronoi regions

• Use of normal tables to jump start Use of normal tables to jump start and avoid local minima problemand avoid local minima problem

• Take advantages of level-of-details Take advantages of level-of-details (multi-resolution) representations(multi-resolution) representations

Implementation: Implementation: SWIFTSWIFT

• Progressive Refinement FrameworkProgressive Refinement Framework

• Faster (2x to 10x ) than any public Faster (2x to 10x ) than any public domain packages for convex objects domain packages for convex objects

• Insensitive to level of motion Insensitive to level of motion coherencecoherence

• Will be available at:Will be available at:

http://www.cs.unc.edu/~geom/SWIFThttp://www.cs.unc.edu/~geom/SWIFT

MotivatioMotivationn

Engine model courtesy of Engineering Animation IncEngine model courtesy of Engineering Animation Inc

Parallel close Parallel close proximity:proximity:piston against piston against combustioncombustionchamber wall chamber wall

Model Courtesy of ABB Engineering, Inc.A Coal-fired Powerplant Model: 15,432,126 triangles

MotivationMotivation

BVH-Based Collision BVH-Based Collision DetectionDetection

• Model Hierarchy: Model Hierarchy: – each node has a simple volume that bounds each node has a simple volume that bounds

a set of triangles a set of triangles – children contain volumes that each bound a children contain volumes that each bound a

different portion of the parent’s triangles different portion of the parent’s triangles – The leaves of the hierarchy usually contain The leaves of the hierarchy usually contain

individual trianglesindividual triangles

• A binary bounding volume hierarchy:A binary bounding volume hierarchy:

BVH-Based Collision BVH-Based Collision DetectionDetection

Higher Order Bounding Higher Order Bounding Volume Hierarchies Volume Hierarchies

• OBBTreeOBBTree: Tree of Oriented : Tree of Oriented Bounding Bounding Boxes Boxes (OBBs)(OBBs)

• SSVSSV: Tree of Swept Sphere : Tree of Swept Sphere Volumes Volumes

OBBTREES: OBBTREES: OrganizationOrganization

• Building an OBBTreeBuilding an OBBTree• Tree TraversalTree Traversal• OBB Overlap TestOBB Overlap Test• PerformancePerformance

Recursive top-down construction: partition and refit

Building an OBB TreeBuilding an OBB Tree

Given some polygons,consider their vertices...


Project onto the line

Consider variance ofdistribution on the line


Given by eigenvectorsof covariance matrix(summarizing the 1st

& 2nd order statistics)of coordinatesof original points


Choose bounding boxoriented this way


… and sample them uniformly


Building an OBB Tree: Building an OBB Tree: SummarySummary

OBB Fitting algorithm:OBB Fitting algorithm:

• Statistics-basedStatistics-based

• Use of convex hullUse of convex hull

• Uniform sampling distributionsUniform sampling distributions

• O(n log n) fitting time for single BVO(n log n) fitting time for single BV

• O(n logO(n log22 n) fitting time for entire tree n) fitting time for entire tree

Tree TraversalTree Traversal

Disjoint bounding volumes:Disjoint bounding volumes:No possible collisionNo possible collision

Overlapping bounding volumes:Overlapping bounding volumes:• split one box into childrensplit one box into children• test children against other boxtest children against other box



First child: no overlapFirst child: no overlap

Second child overlaps:Second child overlaps:• split larger boxsplit larger box• continue testscontinue tests



Hierarchy of testsHierarchy of tests

SeparatingSeparating Axis Axis TheoremTheorem

L is a separating axis for OBBs A & B, since A & B become L is a separating axis for OBBs A & B, since A & B become disjoint intervals under projection onto Ldisjoint intervals under projection onto L

Separating Axis Separating Axis TheoremTheorem

Two polytopes A and B are disjoint iff Two polytopes A and B are disjoint iff therethere

exists a separating axis which is:exists a separating axis which is:

perpendicular to a face from either perpendicular to a face from either

oror

perpedicular to an edge from eachperpedicular to an edge from each

Implications of Implications of TheoremTheorem

Given two generic polytopes, each with E Given two generic polytopes, each with E edges and F faces, number of candidate edges and F faces, number of candidate axes to test is:axes to test is:

2F + E2F + E22

OBBs have only E = 3 distinct edge OBBs have only E = 3 distinct edge directions, and only F = 3 distinct face directions, and only F = 3 distinct face normals. OBBs need at most 15 axis tests.normals. OBBs need at most 15 axis tests.

Because edge directions and normals each Because edge directions and normals each form orthogonal frames, the axis tests are form orthogonal frames, the axis tests are rather simple.rather simple.

OBB Overlap TestOBB Overlap Test

sha

bas h h+>L is a separating axis iff:

L

hb


• Project boxes onto axis. If Project boxes onto axis. If intervals don’t overlap, it is a intervals don’t overlap, it is a separating axis.separating axis.

• A separating axis exists if and only A separating axis exists if and only if boxes are disjoint.if boxes are disjoint.

• 2D OBBs: 4 axes to test2D OBBs: 4 axes to test• 3D OBBs: 15 axes to test 3D OBBs: 15 axes to test


• Typical axis test for 3-space. Typical axis test for 3-space.

• Up to 15 tests required.Up to 15 tests required.

• Typical axis test for 3-space. Typical axis test for 3-space.

• Up to 15 tests required.Up to 15 tests required.

s = fabs(T2 * R11 - T1 * R21);s = fabs(T2 * R11 - T1 * R21);

ha = a1 * Rf21 + a2 * Rf11;ha = a1 * Rf21 + a2 * Rf11;

hb = b0 * Rf02 + b2 * Rf00;hb = b0 * Rf02 + b2 * Rf00;

if (s > (ha + hb)) return 0;if (s > (ha + hb)) return 0;


• Strengths of this overlap test:Strengths of this overlap test:– 80 to 234 arithmetic operations per 80 to 234 arithmetic operations per

box overlap testbox overlap test– No special cases for parallel/coincident No special cases for parallel/coincident

faces, edges, or verticesfaces, edges, or vertices– No special cases for degenerate boxesNo special cases for degenerate boxes– No conditioning problemsNo conditioning problems– Good candidate for micro-coding Good candidate for micro-coding

OBB Overlap Test: OBB Overlap Test: SIMD ImplementationSIMD Implementation

[Jointly with Intel][Jointly with Intel]

• Decompose into 5 sets of axis Decompose into 5 sets of axis teststests– Each set implemented using Katmai Each set implemented using Katmai

SIMD instruction setsSIMD instruction sets– About 2.5 times speedup in practiceAbout 2.5 times speedup in practice

AABB’s vs. OBB’sAABB’s vs. OBB’s

ApproximationApproximation

of a Torusof a Torus

Dynamic SimulationDynamic Simulation

• Interactive Collision Detection on 2 complex Pipelines: Interactive Collision Detection on 2 complex Pipelines: 140K polygons each; 4.2ms on SGI RE/90M Hz140K polygons each; 4.2ms on SGI RE/90M Hz

Engineering AnimationEngineering Animation

• Interference Detection of Interference Detection of Engine ModelEngine Model:: Fixed part: Fixed part: 84,454 triangles; Moving parts: 256,606 triangles84,454 triangles; Moving parts: 256,606 triangles

Simulation-Based Simulation-Based DesignDesign

• Interactive Interference Detection: A Torpedo (4780 Interactive Interference Detection: A Torpedo (4780 polygons) on Pivot Structure (44921 polygons)polygons) on Pivot Structure (44921 polygons)

System DemonstrationSystem Demonstration

VideoVideo

Implementation: RAPIDImplementation: RAPID

• Available at: Available at: http://www.cs.unc.edu/~geom/OBBhttp://www.cs.unc.edu/~geom/OBB

• Part of Part of V-COLLIDEV-COLLIDE: : http://www.cs.unc.edu/~geom/V_COLLIDEhttp://www.cs.unc.edu/~geom/V_COLLIDE

• More than 3000 users have ftp’ed the codeMore than 3000 users have ftp’ed the code

• Used for virtual prototyping, dynamic Used for virtual prototyping, dynamic simulation, robotics and computer animationsimulation, robotics and computer animation

Technology TransferTechnology Transfer

• Virtual Protptyping & VEs: Division, MSC Virtual Protptyping & VEs: Division, MSC Working Knowledge, Prosolvia, Ford, Working Knowledge, Prosolvia, Ford, AmandaSoft, Lockheed-MartinAmandaSoft, Lockheed-Martin

• Computer Animation: Jack/Transom Tech.Computer Animation: Jack/Transom Tech.

• Medical Applications: ADAC LabMedical Applications: ADAC Lab

• Interactive Gaming: Intel, OZ.com, Interactive Gaming: Intel, OZ.com, Blaxxun etc.Blaxxun etc.

Swept Sphere VolumesSwept Sphere Volumes

PSS LSS RSSPSS LSS RSS

Swept Sphere Swept Sphere Volumes (S-topes)Volumes (S-topes)

PSS LSS RSS

SSV FittingSSV Fitting

• Use OBB’s code based upon Use OBB’s code based upon Principle Component AnalysisPrinciple Component Analysis

• For PSS, use the largest dimension For PSS, use the largest dimension as the radiusas the radius

• For LSS, use the two largest For LSS, use the two largest dimensions as the length and radiusdimensions as the length and radius

• For RSS, use all three dimensionsFor RSS, use all three dimensions

Overlap TestOverlap Test

• One routine that can perform One routine that can perform overlap tests between all possible overlap tests between all possible combination of CORE primitives of combination of CORE primitives of SSV(s).SSV(s).

• The routine is a specialized test The routine is a specialized test based on Voronoi regions and OBB based on Voronoi regions and OBB overlap test.overlap test.

• It is faster than GJK.It is faster than GJK.

Hybrid BVH’s based on Hybrid BVH’s based on SSVSSV

• Use a simpler BV when it prunes search Use a simpler BV when it prunes search equally well - benefit from lower cost of equally well - benefit from lower cost of BV overlap testsBV overlap tests

• Overlap test (based on Lin-Canny & OBB Overlap test (based on Lin-Canny & OBB overlap test) between all pairs of BV’s in overlap test) between all pairs of BV’s in a BV family is unifieda BV family is unified

• ComplicationsComplications– deciding which BV to use either deciding which BV to use either dynamicallydynamically

or or staticallystatically

PQP: ImplementationPQP: Implementation

• Library written in C++Library written in C++

• Good for any proximity queryGood for any proximity query

• 5-20x speed-up in 5-20x speed-up in distance distance computationcomputation over prior methods over prior methods

• Available at Available at http://www.cs.unc.edu/~geom/SSV/http://www.cs.unc.edu/~geom/SSV/

PQP: Technology PQP: Technology TransferTransfer

• Released in July’99Released in July’99

• More than 250 active usersMore than 250 active users

• Strong interest from SonyStrong interest from Sony

• Optimized for PS2 applications: Optimized for PS2 applications: only 1-2 routines need only 1-2 routines need optimizationoptimization

System ArchitectureSystem Architecture

DatabaseScene Graph

Overlap Graph

Partition& RefineGraphs

ProximityQueries

Processing Large Processing Large Geometric Databases for Geometric Databases for Massive ModelsMassive Models

Localized Sub-graphs

Encode the proximity relationship with “overlap graphs” topartition massive 3D dataset into smaller, manageable datasets

Localized Sub-graphsLocalized Sub-graphs

• Reduce frequency of disk accessing Reduce frequency of disk accessing

• Runtime ordering & traversalRuntime ordering & traversal

• Localize region of contactsLocalize region of contacts

• Allow modification on the flyAllow modification on the fly

• Prefetch geometryPrefetch geometry

2D Objects2D Objects

• A simple environment consisting of polygonsA simple environment consisting of polygons

Object Bounding BoxesObject Bounding Boxes

• Each object is bounded by a AABB.Each object is bounded by a AABB.

Object NodesObject Nodes

• Each node corresponds to an object.Each node corresponds to an object.

Overlap GraphOverlap Graph

• Each edge corresponds to a potential overlap & each node has a weight Each edge corresponds to a potential overlap & each node has a weight proportional to object memory requirement (polygon # & hierarchies)proportional to object memory requirement (polygon # & hierarchies)

Computing Connected Computing Connected ComponentsComponents

• Identify cacheable componentsIdentify cacheable components

• Object decompositionObject decomposition

• Find high-valence nodesFind high-valence nodes

• Multi-level graph partitioningMulti-level graph partitioning

……Repeat on the resulting cut graph till Repeat on the resulting cut graph till decomposing the overlap graph into localized decomposing the overlap graph into localized subgraphs, such that the weight of each subgraphs, such that the weight of each subgraph < memory cache sizesubgraph < memory cache size

Algorithmic ChoicesAlgorithmic Choices

• Types of Bounding Volumes (e.g. Types of Bounding Volumes (e.g.

spheres, AABBS, OBBs, etc.)spheres, AABBS, OBBs, etc.)

• On-the-fly Hierarchy Construction On-the-fly Hierarchy Construction

& Lazy Evaluation& Lazy Evaluation

IMMPACT: ImplementationIMMPACT: Implementation

• Written in C++ & OpenGLWritten in C++ & OpenGL

• Built on top of PQP (UNC-CH)Built on top of PQP (UNC-CH)

• Use of METIS (University of Minnesota)Use of METIS (University of Minnesota)

• Real-time interaction with CAD modelsReal-time interaction with CAD models

[Eurographics’99][Eurographics’99]

IMMPACT: IMMPACT: DemonstrationDemonstration

Real-time Interaction with PowerPlant (15 million triangles)

Technology Transfer & Technology Transfer & FeedbackFeedback

• 7 Collision Detection & Proximity Systems7 Collision Detection & Proximity Systems

• More than 4500 downloadsMore than 4500 downloads

• More than 40 commercial licensesMore than 40 commercial licenses

• The Collide Inc.The Collide Inc. handles licensing handles licensing

• Useful feedback from our usersUseful feedback from our users

CollaboratorsCollaborators

• Dinesh Manocha Dinesh Manocha • John Canny (Berkeley)John Canny (Berkeley)• Jonathan Cohen (Johns Hopkins)Jonathan Cohen (Johns Hopkins)• Stephen EhmannStephen Ehmann• Stefan Gottschalk (NVidia)Stefan Gottschalk (NVidia)• Eric Larsen (Sony R&D America)Eric Larsen (Sony R&D America)• Brian Mirtich (MERL)Brian Mirtich (MERL)• Amol Pattekar (Yahoo)Amol Pattekar (Yahoo)• Krish PonamgiKrish Ponamgi• Andy WilsonAndy Wilson

• Intel MGL Research GroupIntel MGL Research Group• Sony PS2 R&D GroupSony PS2 R&D Group

AcknowledgmentsAcknowledgments

• Army Research OfficeArmy Research Office

• HondaHonda

• IntelIntel

• National Science FoundationNational Science Foundation

• Office of Naval ResearchOffice of Naval Research

• Sloan FoundationSloan Foundation

fast proximity queries for interactive walkthroughs ming c. lin university of north carolina at...

Documents