I have begun to write the next stage of the dissertation, the survey and analysis stage. I have to maintain a high level of work throughput on this now, producing one or more pages a day ideally. Most of my work up till now has been based on research so it is now a matter of writing this up for the literature survey; I have been researching numerous topics including:
Data Structures to Represent Skeletons
Being a computer scientist data structures are an avid interest to me and it is important that I get the data structure of the skeletal hierarchy correct. There are essentially two most promising solutions to this in C++, one is to use a pointer hierarchy in other words have a node structure that maintains (smart) pointers to other nodes; the other is to use a heap data structure which not only more efficiently supports algorithms such as Dijkstra's shortest path algorithm (potentially useful for constrained Inverse Kinematics) but it can also be efficiently stored as a single array and traversed using iteration. Using an array rather than linked nodes has the additional benefit of a strong locality of reference, specifically spatial locality, which aids in efficient caching to within a modern computer's layered memory model.
Motion Capture File Formats
I have been researching motion capture file formats recently, particularly the BVH file format and the ASF/AMC formats. To this end I have created a BVH file loader prototype which loads and displays the hierarchical structure of the skeleton:
Currently each bone is drawn from the position of it's parent to the position of its joint's offset from that parent, as such there is no rotation happening. The next prototype will support the correct rotations of joints which will allow me to use render using oriented ellipsoids rather than lines. To get to this stage requires the addition of Matrix, Euler-Angle and, perhaps, Quaternion components to the numerics library.
Procedural and Parametric Motion Generation
This topic, I have found, is essentially divided into two parts. One is the generation of long sequences of generation and the other is the generation of slightly altered but short motions.
The generation of long sequences of animation has been achieved in a number of ways, one way is to take motion capture animation, split it up and recombine it into longer chains than can reoccur. Another method is to use parametric equations to generate motion and simply alter the parameters. Finally there is also the analysis of motion capture data using statistical methods and Fourier analysis to extrapolate further motion.
The generation of new short sequences of animation typically involves the blending of several similar animation pieces together to form the new motion, there is a good video on this from one of the most successful attempts to date (2004) by Lucas Kovar and Michael Gleicher (source).
Joint Sliding and Inverse Kinematics
I have done some reading about Inverse Kinematics (IK) which is a commonly used algorithm in computer animation for calculating the angles and motion of joints in order for an end-effector to reach a target point. It gets used at design-time by artists to help pose animations to create key-frames, but it also gets used at run-time. There are two run-time applications of IK that I am interested in, one is to allow extremities such as arms or tails to reach for certain objects in the world correctly and another, more important in my mind, application is to keep the character's feet realistically planted on the ground despite the fact that an animation might have been recorded for a flat surface yet the ground is not flat.
Posts
