CSharpGL(32)矩阵与四元数与角度旋转轴的相互转换

CSharpGL(32)矩阵与四元数与角度旋转轴的相互转换

三维世界里的旋转(rotate)，可以用一个3x3的矩阵描述；可以用（旋转角度float+旋转轴vec3）描述。数学家欧拉证明了这两种形式可以相互转化，且多次地旋转可以归结为一次旋转。这实际上就是著名的轨迹球(arcball)方式操纵模型的理论基础。

本文中都设定float angleDegree为旋转角度，vec3 axis为旋转轴。

+BIT祝威+悄悄在此留下版了个权的信息说：

四元数

+BIT祝威+悄悄在此留下版了个权的信息说：

定义(angleDegree+axis到四元数)

四元数就是一个四维向量(w, x, y, z)，其中w描述旋转的角度（但不是直接的angleDegree值），(x, y, z)描述旋转轴。从angleDegree和axis得到一个四元数的方式比较简单。

    public struct Quaternion
    {
        private float w;
        private float x;
        private float y;
        private float z;
        
        /// <summary>
        /// Quaternion from a rotation angle and axis.
        /// </summary>
        /// <param name="angleDegree">angle in degree.</param>
        /// <param name="axis">rotation axis.</param>
        public Quaternion(float angleDegree, vec3 axis)
        {
            vec3 normalized = axis.normalize();
            double radian = angleDegree * Math.PI / 180.0;
            double halfRadian = radian / 2.0;
            this.w = (float)Math.Cos(halfRadian);
            float sin = (float)Math.Sin(halfRadian);
            this.x = sin * normalized.x;
            this.y = sin * normalized.y;
            this.z = sin * normalized.z;
        }
    }

先别管为什么四元数是这么定义的，只要知道这个定义就好。这里引入四元数只是为了方便提取出矩阵中蕴含的angleDegree和aixs。四元数的其他用途本文不涉及。

+BIT祝威+悄悄在此留下版了个权的信息说：

四元数到angleDegree+axis

从上面的定义可以很容易推算出四元数里蕴含的angleDegree和axis。显然得到的axis已经失去了原有的长度，但是axis的长度并不重要，保持在单位长度才是最方便的。

        public void Parse(out float angleDegree, out vec3 axis)
        {
            angleDegree = (float)(Math.Acos(w) * 2 * 180.0 / Math.PI);
            axis = (new vec3(x, y, z)).normalize();
        }

+BIT祝威+悄悄在此留下版了个权的信息说：

四元数到矩阵

从四元数到矩阵的推导有点复杂，有很多相关文章，本文就只贴代码了。代码还是很简练的。

        /// <summary>
        /// Transform this quaternion to equivalent matrix.
        /// </summary>
        /// <returns></returns>
        public mat3 ToRotationMatrix()
        {
            vec3 col0 = new vec3(
                2 * (x * x + w * w) - 1,
                2 * x * y + 2 * w * z,
                2 * x * z - 2 * w * y);
            vec3 col1 = new vec3(
                2 * x * y - 2 * w * z,
                2 * (y * y + w * w) - 1,
                2 * y * z + 2 * w * x);
            vec3 col2 = new vec3(
                2 * x * z + 2 * w * y,
                2 * y * z - 2 * w * x,
                2 * (z * z + w * w) - 1);

            return new mat3(col0, col1, col2);
        }

实际上得到的矩阵就是这样的：

+BIT祝威+悄悄在此留下版了个权的信息说：

矩阵到四元数

矩阵到四元数的推导也有点复杂，借助了一些数学技巧，本文不详述，直接贴代码。

        /// <summary>
        /// Transform this matrix to a <see cref="Quaternion"/>.
        /// </summary>
        /// <returns></returns>
struct mat3
{
    public Quaternion ToQuaternion()
        {
            // input matrix.
            float m11 = this.col0.x, m12 = this.col1.x, m13 = this.col2.x;
            float m21 = this.col0.y, m22 = this.col1.y, m23 = this.col2.y;
            float m31 = this.col0.z, m32 = this.col1.z, m33 = this.col2.z;
            // output quaternion
            float x = 0, y = 0, z = 0, w = 0;
            // detect biggest in w, x, y, z.
            float fourWSquaredMinus1 = +m11 + m22 + m33;
            float fourXSquaredMinus1 = +m11 - m22 - m33;
            float fourYSquaredMinus1 = -m11 + m22 - m33;
            float fourZSquaredMinus1 = -m11 - m22 + m33;
            int biggestIndex = 0;
            float biggest = fourWSquaredMinus1;
            if (fourXSquaredMinus1 > biggest)
            {
                biggest = fourXSquaredMinus1;
                biggestIndex = 1;
            }
            if (fourYSquaredMinus1 > biggest)
            {
                biggest = fourYSquaredMinus1;
                biggestIndex = 2;
            }
            if (fourZSquaredMinus1 > biggest)
            {
                biggest = fourZSquaredMinus1;
                biggestIndex = 3;
            }
            // sqrt and division
            float biggestVal = (float)(Math.Sqrt(biggest + 1) * 0.5);
            float mult = 0.25f / biggestVal;
            // get output
            switch (biggestIndex)
            {
                case 0:
                    w = biggestVal;
                    x = (m23 - m32) * mult;
                    y = (m31 - m13) * mult;
                    z = (m12 - m21) * mult;
                    break;

                case 1:
                    x = biggestVal;
                    w = (m23 - m32) * mult;
                    y = (m12 + m21) * mult;
                    z = (m31 + m13) * mult;
                    break;

                case 2:
                    y = biggestVal;
                    w = (m31 - m13) * mult;
                    x = (m12 + m21) * mult;
                    z = (m23 + m32) * mult;
                    break;

                case 3:
                    z = biggestVal;
                    w = (m12 - m21) * mult;
                    x = (m31 + m13) * mult;
                    y = (m23 + m32) * mult;
                    break;

                default:
                    break;
            }

            return new Quaternion(w, -x, -y, -z);
        }
    }

好了，现在矩阵 ⇋ 四元数 ⇋ (angleDegree+axis)之间的转换就全有了。

BTW，OpenGL里的glRotate{fd}(angle, axis)里的angle是以角度为单位的。为了统一，我将CSharpGL里的所有angle都设定为以角度为单位了。

+BIT祝威+悄悄在此留下版了个权的信息说：

下载

CSharpGL已在GitHub开源，欢迎对OpenGL有兴趣的同学加入（https://github.com/bitzhuwei/CSharpGL）

+BIT祝威+悄悄在此留下版了个权的信息说：

总结

现在解决了矩阵与（angleDegree+axis）之间的转换问题，就可以从容地解析轨迹球算出的旋转矩阵，抽取出里面蕴含的（angleDegree+axis）了。这就可以单独更新模型的旋转角度和旋转轴，避免了对整个模型矩阵的破坏。