Footskate Solver
Open Source Release
|
|
A new version of the code and documentation will be posted soon. The code has been updated to be more readable, and some clarifications have been made to the documentation. Please check back after December 9th.
This page provides an C++ implementation of the Footskate/Handplant solver described in the paper:
Lucas Kovar John Schreiner Michael Gleicher. Footskate Cleanup for Motion Capture Editing. Proceedings of the 2002 ACM Symposium on Computer Animation (SCA). July 2002.
http://www.cs.wisc.edu/graphics/Papers/Gleicher/Mocap/cleanup.pdf
The solver is provided freely as "open source" under a very simple license, described below, by the University of Wisconsin Graphics Group.
This implementation was originally created by John Schreiner in 2002. Joshua Lulewicz was responsible for this version, created to simplify integration into other systems. Josh also wrote the documentation. These students have assigned their rights to the code and documentation to Michael Gleicher who supervised the project.
The provided implementation has been compiled with Microsoft Visual C++ .NET ver 7.1.3088, and has been successfully integrated within several animation systems developed within the University of Wisconsin Graphics Group. There is little system specific code, so it should compile on other systems or with other compilers, however, we make no promises.
"Footskate" refers to the problem of end-effectors not staying in a specified position when they should. This is most often seen on a characters feet: when a step is taken the foot might slide around a little, even though it should be planted.
While we use the term "footskate," our implementation is not specific to feet: it works on the arms as well. We do assume that each limb consists of two links, follwed by a link for the end-effector (the foot or hand). In fact, our solution is general enough that it can be used as a general purpose Inverse Kinematics (IK) solver for human figures - it does not require the hands and feet to be "planted" in particular places.
The solver takes a list of "constraints" (that is a specification that says a particular end effector must be in a certain place at a certain time) and a motion and alters the motion such that the constraints are met.
The process of altering the end effector positions of an animated character is more complex than simply performing an inverse kinematics calculation to determine the new joint angles to achieve the target positions. Care must be taken such that no new discontinuities or other artifacts are introduced in the animation. Our approach, described in the paper, uses a carefully designed closed-form IK solver to insure continuous outputs given continuous inputs, and applies blending to deal with discontinuous switches (e.g. at the beginning and end of a footplant).
The solver is provided as a library. The interface is designed to make it easy to integrate into systems that use different representations of animation data. We have successfully used the solver in many projects.
Our solver is designed for interactive applications and is very fast. All computations are closed form. In fact, it often takes as much time to copy/convert animation information into our datastructures as it does to perform the solution.
The Footskate Solver is provided under the following "BSD" style license:
Copyright (c) 2004, Michael L. Gleicher All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
This license was chosen because it provides minimal restrictions on how you can use our work.
While the license does not require it, we would appreciate it if you give attribution to our work. For example, if you use our code in a research project, mention it in your publications (such as "we used the Footskate solver provided by the Wisconsin Graphics Group", along with a citation to the paper describing the solver).
Also, if you are successfully using the solver, please let us know - we're always interested in hearing success stories. While we cannot provide any support for using the solver, suggestions on how to make the code more useful are welcomed, even though we cannot promise to make use of them.
The 7 C++ files (3 source files, 4 header files) and license as a ZIP archive.
While the license does not require it, we would prefer that you link to this page, rather than to the ZIP file directly as it may move.
Again, while not required by the license, we would be interested in hearing your experience using the solver. (although, we cannot offer any support)
The solver itself is usually called using the function ikBlendSolve
in the iksolver.cpp file. To call this, an array of ikConstraint
must be created, one for each frame of the animation. This ikConstraint
structure holds all of the information about the character's skeleton and the
constraints.
The code is most easily used by copying the required information into the ikConstraint
data structures. This allows you to convert from your internal representation
into our form (which is designed to be easy for the solver). The solver returns
an array of ikPose data structures, that can be copied back into
your preferred representation.
It is also possible to use the solver in an on-line manner.
See Josh's documentation for more information.
This page was written by Michael Gleicher in July of 2004.
This page Copyright (C) 2004, Michael L. Gleicher