解构变换矩阵：如何使变换矩阵分解为位移(T)，旋转(R)，缩放(S)矩阵

解构变换矩阵

 

给定一个转换的复合矩阵，关于组成该转换的任何单个转换的信息就会丢失。 我们如果有一个复合矩阵，怎么能使其分解为TRS三个矩阵呢？即如何完成下述变化：

其中M是给定的变换矩阵，T是平移矩阵，R是旋转矩阵，S是缩放矩阵。其中提取T矩阵使非常简单的。因为我们知道平移矩阵形式为：

所以我们可以通过M[0][3]，M[1][3]，M[2][3]来分别找到xyz的位移量。我们可以写出：

T->x = m.m[0][3];
T->y = m.m[1][3];
T->z = m.m[2][3];

我们的M矩阵删除掉平移的元素，就只剩下旋转和缩放了。因此在删除平移后，剩下的是上面的3*3矩阵，它们一起表示缩放和旋转。 该矩阵被复制到新矩阵M中以进行进一步处理：

//获取除去平移的新矩阵M
Matrix4x4 M = m;
for (int i = 0; i < 3; ++i)
    M.m[i][3] = M.m[3][i] = 0.0f;
M.m[3][3] = 1.0f;

接下来就是如何去获取旋转矩阵了。只要获得旋转矩阵，那么缩放矩阵也就可以直接通过：

计算得出。接下来，我们要提取M的纯旋转分量R。我们将使用一种称为"极分解(polar decomposition)"的技术来做到这一点。 可以证明，矩阵M的极分解可以分解为旋转R和缩放S。该方法通过对M的逆的转置进行连续平均来计算：

直到收敛，此时Mi = R。（很容易看出，如果M是纯旋转，则对其进行求逆再转置平均将使其保持不变，因为其逆等于其转置）。我们可以看旋转矩阵的形式：

因为旋转矩阵为正交阵，满足上述操作。Shoemake和Duff（1992）讨论了该级数收敛的证明，所得矩阵是最接近M的正交矩阵，这是理想的特性。为了计算该序列，我们迭代应用公式，直到连续项之间的差很小或执行了固定的迭代次数为止。 实际上，该系列通常会很快收敛。我们代码如下：

    // 从M分离出R
    Float norm;
    int count = 0;
    Matrix4x4 R = M;
    do {
        // 计算Mi+1
        Matrix4x4 Rnext;
        Matrix4x4 Rit = Inverse(Transpose(R));
        for (int i = 0; i < 4; ++i)
            for (int j = 0; j < 4; ++j)
                Rnext.m[i][j] = 0.5f * (R.m[i][j] + Rit.m[i][j]);

        // 计算Mi和Mi+1之间的差
        norm = 0;
        for (int i = 0; i < 3; ++i) {
            Float n = std::abs(R.m[i][0] - Rnext.m[i][0]) +
                      std::abs(R.m[i][1] - Rnext.m[i][1]) +
                      std::abs(R.m[i][2] - Rnext.m[i][2]);
            norm = std::max(norm, n);
        }
        R = Rnext;
    } while (++count < 100 && norm > .0001)//当迭代次数超过上限，或者连续项之间的差足够小，则退出循环;

获得R之后就可以轻松计算S：
 

*S = Matrix4x4::Mul(Inverse(R), M);

我们完整的解构代码如下：

void AnimatedTransform::Decompose(const Matrix4x4 &m, Vector3f *T,
                                  Quaternion *Rquat, Matrix4x4 *S) {
    // 获取平移T
    T->x = m.m[0][3];
    T->y = m.m[1][3];
    T->z = m.m[2][3];

    // 获取除去平移的新矩阵M
    Matrix4x4 M = m;
    for (int i = 0; i < 3; ++i) M.m[i][3] = M.m[3][i] = 0.f;
    M.m[3][3] = 1.f;

    // 从M分离出R
    Float norm;
    int count = 0;
    Matrix4x4 R = M;
    do {
        // 计算Mi+1
        Matrix4x4 Rnext;
        Matrix4x4 Rit = Inverse(Transpose(R));
        for (int i = 0; i < 4; ++i)
            for (int j = 0; j < 4; ++j)
                Rnext.m[i][j] = 0.5f * (R.m[i][j] + Rit.m[i][j]);

        // 计算Mi和Mi+1之间的差
        norm = 0;
        for (int i = 0; i < 3; ++i) {
            Float n = std::abs(R.m[i][0] - Rnext.m[i][0]) +
                      std::abs(R.m[i][1] - Rnext.m[i][1]) +
                      std::abs(R.m[i][2] - Rnext.m[i][2]);
            norm = std::max(norm, n);
        }
        R = Rnext;
    } while (++count < 100 && norm > .0001)//当迭代次数超过上限，或者连续项之间的差足够小，则退出循环;
    // 获取旋转矩阵的四元数形式
    *Rquat = Quaternion(R);

    // 计算缩放矩阵S
    *S = Matrix4x4::Mul(Inverse(R), M);
}