Question

我的四元数数学有点生疏，我想弄清楚以下哪个实现更正确......

看这里你可以看到微软用四元数转换向量的版本：https://referencesource.microsoft.com/#System.Numerics/System/Numerics/Vector3.cs,347

这是代码，它显然已经过优化：

        public static Vector3 Transform(Vector3 value, Quaternion rotation)
        {
            float x2 = rotation.X + rotation.X;
            float y2 = rotation.Y + rotation.Y;
            float z2 = rotation.Z + rotation.Z;
 
            float wx2 = rotation.W * x2;
            float wy2 = rotation.W * y2;
            float wz2 = rotation.W * z2;
            float xx2 = rotation.X * x2;
            float xy2 = rotation.X * y2;
            float xz2 = rotation.X * z2;
            float yy2 = rotation.Y * y2;
            float yz2 = rotation.Y * z2;
            float zz2 = rotation.Z * z2;
 
            return new Vector3(
                value.X * (1.0f - yy2 - zz2) + value.Y * (xy2 - wz2) + value.Z * (xz2 + wy2),
                value.X * (xy2 + wz2) + value.Y * (1.0f - xx2 - zz2) + value.Z * (yz2 - wx2),
                value.X * (xz2 - wy2) + value.Y * (yz2 + wx2) + value.Z * (1.0f - xx2 - yy2));
        }

然而，这给我自己的（未优化的）实现带来了不同的结果：

        public static Vector3 Transform(this Vector3 value, Quaternion rotation)
        {
            var q = new Quaternion(value.X, value.Y, value.Z, 0.0f);
            var res = rotation.Conjugate() * q * rotation;
            return new Vector3(res.X, res.Y, res.Z);
        }

        public static Quaternion operator *(Quaternion value1, Quaternion value2)
        {
            // 9 muls, 27 adds
            var tmp_00 = (value1.Z - value1.Y) * (value2.Y - value2.Z);
            var tmp_01 = (value1.W + value1.X) * (value2.W + value2.X);
            var tmp_02 = (value1.W - value1.X) * (value2.Y + value2.Z);
            var tmp_03 = (value1.Y + value1.Z) * (value2.W - value2.X);
            var tmp_04 = (value1.Z - value1.X) * (value2.X - value2.Y);
            var tmp_05 = (value1.Z + value1.X) * (value2.X + value2.Y);
            var tmp_06 = (value1.W + value1.Y) * (value2.W - value2.Z);
            var tmp_07 = (value1.W - value1.Y) * (value2.W + value2.Z);
            var tmp_08 = tmp_05 + tmp_06 + tmp_07;
            var tmp_09 = (tmp_04 + tmp_08) * 0.5f;

            return new Quaternion(
                tmp_01 + tmp_09 - tmp_08,
                tmp_02 + tmp_09 - tmp_07,
                tmp_03 + tmp_09 - tmp_06,
                tmp_00 + tmp_09 - tmp_05
                );
        }

由于这些不会给出相同的结果，其中一个肯定是错误的，但到底是哪个，为什么？

我自己的实现似乎在我尝试使用它的情况下有效，并且 MS 实现似乎已损坏，但如果它实际上不正确，我会感到惊讶，因为我认为它被广泛使用...

谢谢！ :)

Answer 1

通过四元数旋转向量有两种不同的约定，左链和右链。例如，

vnew = q * v * conjugate(q) <-- 这是左链（连续旋转在左边叠加）

vnew = conjugate(q) * v * q <-- 这是右链（连续旋转在右边叠加）

左链约定通常用于主动旋转，其中四元数用于在坐标系内旋转向量。即 v 和 vnew 是在同一坐标系内协调的两个不同向量。

右链约定通常用于被动旋转，例如表示坐标系变换的四元数。即 v 和 vnew 实际上是同一个向量，只是在两个不同的坐标系中进行了协调。

您上面显示的 MS 代码是左链约定，但您的代码是右链约定。因此结果不同。

这两种约定都是有效的并且都有其用途，但是从在线资源中提取代码时需要非常小心。您需要验证代码使用的约定是什么才能正确使用它。并且您需要确保约定与您在特定应用程序中使用四元数的方式相匹配。

四元数矢量旋转

1 个答案: