Efficient Maintenance and Self-Collision Testing for Kinematic Chains

1
Efficient Maintenance and Self-Collision Testing
for Kinematic Chains

• Itay Lotan
• Fabian Schwarzer
• Dan Halperin
• Jean-Claude Latombe

2
Motivation

• Robotics Snake-like robots
• Biology Motion of macro-molecules

protein backbone
(Mark Yim)
3
Properties of Kinematic Chains

• 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

4
Problem Description

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

• Update the chain at each time-step to reflect the
  changes
• Assuming no self-collisions at previous
  time-step, find self-collisions caused by latest
  changes

5
Existing Techniques
Updating Self-collisions
I-COLLIDE (Cohen et al 95)
GRID (e.g. Halperin and Overmars 98)
BV Hierarchies (Quinlan 94, Gottschalk et al 96, van den Bergen 97, Klosowski et al 98)
Dynamic Kinematic Structures (Halperin et al 96)
6
Our Algorithm

• updating per time-step
• worst-case self-collision detection
  per time-step. Much faster in practice
• Novel chain representation based on
• Transformations hierarchy to approximate the
  kinematics at different resolutions
• OBB hierarchy to approximate the geometry at
  different resolutions

7
Chain Representation
A Sequence of reference frames (links) connected
by rigid-body transformations (joints)
Hierarchy of shortcut transformations
8
Bounding Volume Hierarchy

• Chain-aligned bottom-up, along the chain
• Each BV encloses its two children in the
  hierarchy
• Shortcuts allow to efficiently compute relative
  position of BVs
• At each time step only BVs that contain the
  changed joints need to be recomputed

9
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

10
Self-Collision Example
11
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 change an OBB hierarchy is
  built for each rigid piece of the chain. Each
  pair of hierarchies is tested for collisions

12
Results Extended Chain (1)
Single Joint Change
13
Results Extended Chain (2)
100 Joint Changes
14
Protein Backbones
1LOX (1941 atoms)
1B4E (969 atoms)
1SHG (171 atoms)
15
Results Protein Backbones (1)
Single Joint Change
16
Results Protein Backbones (2)
10 Joint Changes
17
Analysis Updating

• For each joint change
• shortcut transformations need to
  be recomputed
• BVs need to be recomputed
• For k simultaneous changes time,
  but never more than

Previous BV hierarchies required O(N log N)
updating time
18
Analysis Collision Detection
in the worst case

• Upper bound is stable - holds for not so tight
  hierarchies like ours
• Lower bound is stable for any convex BV
• Slightly worse than bound we prove for
  a regular hierarchy
• If topology of regular hierarchy is not updated,
  can deteriorate to

19
Proof of Upper Bound

• Will the bound hold for a not so tight
  hierarchy like ours?

YES!

• OBBs are larger than tight bounding spheres by a
  constant factor at each level
• This factor is fixed for all levels of the
  hierarchy

20
Proof of Lower Bound

• 3d links form a unit
• d/8 units shifted by 1 along X and -Y form a
  layer
• d/8 layers shifted by 1 along Y and Z form a
  chain

chain
Convex hull of all units overlaps!
P2(d-1),d-1,(d-1)/4
layer
21
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 ltlt N

22
Current Work

• Applying the algorithm to Monte-Carlo simulation
  of proteins
• Allow tree-like structure with short branches to
  model side-chains
• Replace collision detection with distance
  computation
• Efficiently compute internal energy by reusing
  unchanged terms