Skeletal animation, forward kinematic

Cheat sheet, common matrix operations associated to linear blending skinning - 11/2016 - #Skinning

Linear Blending Skinning (LBS) formula

$$ \begin{equation*}
\bar{\mathbf{p_i}} = \sum_{j=1}^{n} w_{ij} T_j \mathbf{p_i}
\end{equation*} $$

$n$ number of bones
$w_{ij}$ scalar weight at the i$^{\text{th}}$ vertex associated to the j$^{\text{th}}$ bone
$T_j$ the 4x4 matrix, the global transformation of the j$^{\text{th}}$ bone from its rest pose.
$\mathbf{p_i}$ mesh's vertex in rest pose
$\bar{\mathbf{p_i}}$ the vertex after deformation.

Vec3 linear_blending_skinning(
        const std::vector< std::map<int, float> >& skinning_weights,
        const std::vector<Mat4x4>& skinning_transfos,
        const std::vector<Point3>& in_vertex,
        const std::vector<Vec3>& in_normal,
        std::vector<Point3>& out_vertex,
        std::vector<Vec3>& out_normal)
{
    for(int i = 0; i < skinning_weights.size(); ++i) // For each vertex
    {
        Mat4x4 blend_matrix = Mat4x4::null();
        std::map<int, float> bones = skinning_weights[i];
        for( std::pair<int, float> pair : bones) { // For each bone 
            blend_matrix += skinning_transfos[ pair.first ] * pair.second;
        }
        out_normal[i] = blend_matrix.get_mat3x3().inverse().transpose() * in_normal[i];
        out_vertex[i] = blend_matrix * in_vertex[i];
    }
}

Computing $T_j$ (skinning transformation)

$$ \begin{equation*}
T_j = W_j (B_j)^{-1}
\end{equation*} $$

$W_j $ joint's world matrix in its current animated position.
$B_j $ joint's bind matrix in world coordinates, bind matrix is saved at rest position / T-pose of the skeleton. In short, it is the joint's current orientation when binding the mesh to the skeleton.

The global bind pose $ B_j $ is computed by multiplying the chain of local bind matrices. The global animated pose $W_j$ is computed by multiplying the chain of local bind matrices interleaved with input user transformations:

$$ \begin{equation*} \begin{split} W_j &= L_{\text{root}} Ul_{\text{root}} \ \cdots \ L_{p(j)} Ul_{p(j)} \ L_j Ul_j \\ W_j &= W_{p(j)} L_j Ul_j \\ B_j &= L_{\text{root}} \ \cdots L_{p(j)} \ L_j \\ B_j &= B_{p(j)} L_j \\ \end{split} \end{equation*} $$

$ p(j) $ parent index of the $j^\text{th}$ joint
$ L_j $ local transformation (according to the parent joint) of the joint in rest pose.
$ Ul_j $ local transformation defined by the user.

Procedure to compute the global skinning transformation $T_j$ by specifying a local transformation at each joint:

void compute_skinning_transformations(Mat4x4* tr) {
    rec_skinning_transfo(tr, g_skel.root(), Mat4x4::identity() );
}

void rec_skinning_transfo(Mat4x4* transfos, int id, const Mat4x4& parent)
{
    // W_j = W_p(j) * L_j * Ul_j
    Mat4x4 world_pos = parent * g_skel.bind_local(id) * g_user_local[id]; 
    // T_j = W_j (B_j)^-1
    transfos[id] = world_pos * g_skel.bind(id).inverse(); 
    for(unsigned i = 0; i < g_skel.sons( id ).size(); i++)
        rec_skinning_transfo(transfos, g_skel.sons( id )[i], world_pos);
}

If you don't have access to the local transformation of the joint $ Ul_j $ you can compute $T_j$ given the current world position of the joint:

for(int i = 0; i < bones.size(); ++i) {
    Mat4x4 tr = bone_world_transfo(i) * bind[i].inverse(); // T_j = W_j (B_j)^-1
    skinning_transfo[i] = tr;
}

Computing $L_j$ (bind local matrix)

If only the world bind pose $ B_j $ is known you can find back the local bind pose $ L_j $ with:

$$ \begin{equation*}
L_j = (B_{p(j)})^{-1} B_j
\end{equation*} $$

Computing $W_j$ (joint world matrix)

Given a joint in rest pose $ B_j $ you can find back its animated position just apply the current skinning transformation $ T_j$:

$$ \begin{equation*} W_j = T_j \ . \ B_j \end{equation*}$$

Computing $ Ul_j $ (user local transformation)

You can extract the user local transformation $ Ul_j $ from the joints world matrix $ W $:
$$
\begin{equation*} \begin{split}
W_j & = W_j \\
W_{p(j)} L_j Ul_j & = W_j \\
L_j Ul_j & = (W_{p(j)})^{-1} W_j \\
Ul_j & = (L_j)^{-1} (W_{p(j)})^{-1} W_j \\
Ul_j & = (W_{p(j)} L_j)^{-1} W_j \\
\end{split} \end{equation*}
$$

Set $ Ul_j $ (user local transformation)

Say we seek to update the local user transformation $Ul_j$. We could reset it to a new value $Ul'_j$ or apply an incremental transformation $ Ul'_j = Incr_j \ \ Ul_j $.

But what if we only have access to $ U_j $, an incremental user transformation in world space? With $ U_j $ we can directly transform an animated joint $ W_j $ to its new position $ W'_j $:

$$ \begin{equation*}
\begin{split}
W'_j & = U_j W_j \\
(L_{\text{root}} Ul_{\text{root}} \ \cdots \ L_{p(j)} Ul_{p(j)} L_j Ul'_j) & = U_j W_j \\
(W_{p(j)} L_j Ul'_j) & = U_j W_j \\
\end{split}
\end{equation*}$$

Since we seek the new local user transformation $ Ul'_j $ lets isolate it:

$$ \begin{equation*}
\begin{split}
(W_{p(j)} L_j Ul'_j) & = U_j W_j\\
( L_j Ul'_j) & = (W_{p(j)})^{-1} U_j W_j \\
Ul'_j & = (L_j)^{-1} (W_{p(j)})^{-1} U_j W_j
\end{split}
\end{equation*}$$

Reference

Vertex skinning with GLSL
Smooth skinning tutorial
LBS with Quaternions

No comments

Rodolphe Vaillant's homepage

Research, teaching and more...

Skeletal animation, forward kinematic

Linear Blending Skinning (LBS) formula

Computing \(T_j\) (skinning transformation)

Computing \(L_j\) (bind local matrix)

Computing \(W_j\) (joint world matrix)

Computing \( Ul_j \) (user local transformation)

Set \( Ul_j \) (user local transformation)

Reference