Efficient Maintenance and Self-Collision Testing for Kinematic Chains

Itay LotanFabian Schwarzer

Dan HalperinJean-Claude Latombe

Motivation

Robotics: hyper-redundant snake-like robots

(Mark Yim)(Joel Burdick)

Motivation – cont.

Molecular Simulation – exploring the conformational space of polypeptides

(4PTI backbone)

Motivation – cont.

Both types of applications require: Efficient updating of the chain after

changes to its DOFs Efficient detection of self-collisions

caused by these changes

Outline of Talk

Description of the Problem Previous approaches Our chain representation Detecting self-collisions Experimental results Analysis and theoretical results Conclusions

Outline of Talk

Description of the Problem Previous approaches The chain representation Detecting self-collisions Experimental results Analysis and theoretical results Conclusions

Problem Description

Update the chain at each time-step to reflect the changes

Assuming no self-collisions at previous time-step, find any/all self-collisions caused by latest changes

Given a chain of N links which deforms over time through changes to its DOFs:

Outline of Talk

Description of the Problem Previous approaches The chain representation Detecting self-collisions Experimental results Analysis and theoretical results Conclusions

I-COLLIDE (Cohen et al ’95)

Project objects onto each axis

Sort intervals Find pairs of

intervals that overlap on all axes

Reuse previous order to speed up sorting at next time-step O(N) update time

O(N) detection time

Grid (e.g. Halperin and Overmars ’98)

Insert objects into grid one at a time

Check inserted objects for collisions with objects in neighboring cells

O(N) update time

O(N) detection time

Bounding Volume Hierarchies

Spheres (Quinlan ’94)

OBBs (Gottschalk et al ’96)

AABBs (van den Bergen ’97)

k-DOPs (Klosowski et al ’98)

Build a BV hierarchy Test the hierarchy

against itself to find collisions

At each time step update the BVs

O(N logN) update time

Ω(N) detection time

Previous Approaches - Drawbacks In a kinematic chain – local changes

have global effects. One change may cause O(N) links to move

When few changes are applied to the

chain, large pieces of it remain rigid.

Maintenance of Kinematic Structures (Halperin et al ’96)

Algorithm for dynamic maintenance of kinematic chains

Does not support self-collision testing

update time O N

Outline of Talk

Description of the Problem Previous approaches The chain representation Detecting self-collisions Experimental results Analysis and theoretical results Conclusions

Chain RepresentationA Sequence of reference frames connected by rigid-body transformations

TT(R,t)

TT(R,t)

TT(R,t)

TT(R,t)TT(R,t)

TT(R,t)

TT(R,t)

TT(R,t) TT(R,t) TT(R,t)

TT(R,t)

Hierarchy of shortcut transformations

Bounding Volume Hierarchy Chain-aligned: bottom-up, along the chain Each BV encloses its two children in the

hierarchy Each BV is stored in the reference frame of its

left-most link. At each time step only BVs that contain the

changed joints need to be recomputed

Outline of Talk

Description of the Problem Previous approaches The chain representation Detecting self-collisions Experimental results Analysis and theoretical results Conclusions

Self-Collision Detection

Test the hierarchy against itself to find collisions. But …

Do not test inside BVs that were not updated after the last set of changes

Benefits: Many unnecessary overlap tests are

avoided No leaf node tested against itself.

Self-Collision: Example

Outline of Talk

Previous approaches Description of the Problem The chain representation Detecting self-collisions Experimental results Analysis and theoretical results Conclusions

Experimental Results We tested our algorithm (dubbed

ChainTree) against three others: Grid – Collisions detected by indexing

into a 3D grid using a hash table. 1-OBBTree – An OBB hierarchy is

created from scratch after each change and then tested against itself for collisions.

K-OBBTree – After each move an OBBTree is built for each rigid piece of the chain. Each pair of OBBTrees is tested for collisions.

Results – Compact Chain

Results – Protein Backbones

Outline of Talk

Previous approaches Description of the Problem The chain representation Detecting self-collisions Experimental results Analysis and theoretical results Conclusions

Analysis – Updating

For each joint change: O(log N) shortcut transformations

need to be recomputed O(log N) BVs need to be recomputed

For k simultaneous changes O(k log N) time, but never more than O(N)

Previous BV hierarchies required O(N log N) updating time

Analysis – Collision Detection

This bound is very stable - holds for “not so tight” hierarchies like ours

Lower bound holds for any convex BV. Slightly worse than Θ(N) we show for a

regular hierarchy If topology of regular hierarchy is not

updated, can deteriorate to Θ(N2)

43( )N in the worst case

Outline of Talk

Previous approaches Description of the Problem The chain representation Detecting self-collisions Analysis and theoretical results Experimental results Conclusions

Conclusions

We presented an algorithm for efficient maintenance and self-collision detection of kinematic chains

update time and detection time in the worst case

It is very fast in practice Most efficient when k << N

( log )O k N43( )N