查找表示从一个向量到另一个向量的旋转的四元数

Question

我有两个向量 u 和 v。有没有办法找到表示从 u 到 v 的旋转的四元数？

Answer 1

Quaternion q;
vector a = crossproduct(v1, v2);
q.xyz = a;
q.w = sqrt((v1.Length ^ 2) * (v2.Length ^ 2)) + dotproduct(v1, v2);

不要忘记标准化 q。

理查德关于不存在唯一旋转的说法是正确的，但上面应该给出“最短弧线”，这可能正是您所需要的。

Answer 2

半程矢量解决方案

我想出了一个我相信 Imbrondir 试图呈现的解决方案（尽管有一个小错误，这可能就是为什么 sinisterchipmunk 无法验证它）。

假设我们可以构造一个表示绕轴旋转的四元数，如下所示：

q.w == cos(angle / 2)
q.x == sin(angle / 2) * axis.x
q.y == sin(angle / 2) * axis.y
q.z == sin(angle / 2) * axis.z

两个归一化向量的点积和叉积为：

dot     == cos(theta)
cross.x == sin(theta) * perpendicular.x
cross.y == sin(theta) * perpendicular.y
cross.z == sin(theta) * perpendicular.z

视为从 u 到 v 的旋转> 可以通过围绕垂直向量旋转 theta（向量之间的角度）来实现，看起来我们可以直接从点积和叉积的结果构造一个表示这种旋转的四元数； 然而，就目前情况而言，theta = angle / 2，这意味着这样做会导致所需旋转的两倍。

一种解决方案是计算 u 和 v 之间的向量，并使用 u 和 的点积和叉积half-way 向量来构造一个四元数，表示 u 和 half-way 向量之间角度的旋转两倍，其中带我们一路到达v！

有一种特殊情况，其中 u == -v 和唯一的中途向量变得无法计算。 这是预期的，因为有无限多个“最短弧”旋转可以将我们从 u 带到 v，并且我们必须简单地围绕与 u 正交的任何向量旋转 180 度strong>u（或v）作为我们的特殊情况解决方案。 这是通过获取 u 与任何其他不平行于 u 的向量的归一化叉积来完成的。

接下来是伪代码（显然，实际上，特殊情况必须考虑浮点不准确性——可能通过根据某个阈值而不是绝对值检查点积）。

另请注意，当 u == v 时没有特殊情况（生成单位四元数 - 亲自检查并查看）。

// N.B. the arguments are _not_ axis and angle, but rather the
// raw scalar-vector components.
Quaternion(float w, Vector3 xyz);

Quaternion get_rotation_between(Vector3 u, Vector3 v)
{
  // It is important that the inputs are of equal length when
  // calculating the half-way vector.
  u = normalized(u);
  v = normalized(v);

  // Unfortunately, we have to check for when u == -v, as u + v
  // in this case will be (0, 0, 0), which cannot be normalized.
  if (u == -v)
  {
    // 180 degree rotation around any orthogonal vector
    return Quaternion(0, normalized(orthogonal(u)));
  }

  Vector3 half = normalized(u + v);
  return Quaternion(dot(u, half), cross(u, half));
}

orthogonal 函数返回与给定向量正交的任何向量。 该实现使用具有最正交基向量的叉积。

Vector3 orthogonal(Vector3 v)
{
    float x = abs(v.x);
    float y = abs(v.y);
    float z = abs(v.z);

    Vector3 other = x < y ? (x < z ? X_AXIS : Z_AXIS) : (y < z ? Y_AXIS : Z_AXIS);
    return cross(v, other);
}

半路四元数解决方案

这实际上是已接受的答案中提出的解决方案，它似乎比中路向量解决方案稍微快一些（根据我的测量，快约 20％，尽管不要相信我的话）。 我将其添加到此处，以防像我这样的其他人对解释感兴趣。

本质上，您可以计算导致所需旋转两倍的四元数（如其他解决方案中详细说明），并找到该角度和零度之间的四元数，而不是使用半程向量计算四元数。

正如我之前所解释的，双倍所需旋转的四元数是：

q.w   == dot(u, v)
q.xyz == cross(u, v)

零旋转的四元数是：

q.w   == 1
q.xyz == (0, 0, 0)

计算中途四元数只是将四元数相加并将结果标准化的问题，就像矢量一样。 然而，与向量的情况一样，四元数必须具有相同的大小，否则结果将偏向具有较大大小的四元数。

由两个向量的点积和叉积构建的四元数将与这些乘积具有相同的量级：length(u) * length(v)。 我们可以放大单位四元数，而不是将所有四个分量除以这个因子。 如果您想知道为什么使用 sqrt(length(u) ^ 2 * length(v) ^ 2) 接受的答案似乎使问题变得复杂，这是因为向量的平方长度计算起来更快比长度，所以我们可以节省一次 sqrt 计算。 结果是：

q.w   = dot(u, v) + sqrt(length_2(u) * length_2(v))
q.xyz = cross(u, v)

然后对结果进行归一化。 伪代码如下：

Quaternion get_rotation_between(Vector3 u, Vector3 v)
{
  float k_cos_theta = dot(u, v);
  float k = sqrt(length_2(u) * length_2(v));

  if (k_cos_theta / k == -1)
  {
    // 180 degree rotation around any orthogonal vector
    return Quaternion(0, normalized(orthogonal(u)));
  }

  return normalized(Quaternion(k_cos_theta + k, cross(u, v)));
}

Answer 3

所述问题没有明确定义：给定的向量对不存在唯一的旋转。 例如，考虑 u = <1, 0, 0> 和 v = <0, 1, 0> 的情况。 从 u 到 v 的一次旋转将是绕 z 轴的 pi / 2 旋转。 从 u 到 v 的另一个旋转是围绕向量 <1, 1, 0> 的 pi 旋转。

Answer 4

我对四元数不太擅长。 然而，我为此苦苦挣扎了几个小时，无法使 Polaris878 解决方案发挥作用。 我尝试过预规范化 v1 和 v2。 标准化 q。 标准化 q.xyz。 但我还是不明白。 结果还是没有给我正确的结果。

但最终我找到了一个可行的解决方案。 如果它对其他人有帮助，这是我的工作（python）代码：

def diffVectors(v1, v2):
    """ Get rotation Quaternion between 2 vectors """
    v1.normalize(), v2.normalize()
    v = v1+v2
    v.normalize()
    angle = v.dot(v2)
    axis = v.cross(v2)
    return Quaternion( angle, *axis )

如果 v1 和 v2 是并行的，则必须做出特殊情况，例如 v1 == v2 或 v1 == -v2 （具有一定的容忍度），我认为解决方案应该是四元数(1, 0,0,0)（无旋转）或四元数(0, *v1)（180 度旋转）

Answer 5

要找到将 u 旋转到 v 的最小旋转四元数，请使用

align(quat(1, 0, 0, 0), u, v)

通用解决方案

function align(Q, u, v)
    U = quat(0, ux, uy, uz)
    V = quat(0, vx, vy, vz)
    return normalize(length(U*V)*Q - V*Q*U)

为什么要进行此通用化？

R = align(Q, u, v)

最重要的是，R是最接近Q的四元数，其局部u方向全局指向v方向。 因此，R 是最接近 Q 的四元数，它将把 u 旋转到 v。

这可用于为您提供所有可能的旋转，从 u 旋转到 v，具体取决于 Q 的选择。 如果您想要从 u 到 v 的最小旋转（如其他解决方案所示），请使用 Q = quat(1, 0, 0, 0)。

最常见的是，我发现您想要执行的实际操作是一个轴与另一个轴的一般对齐。

// If you find yourself often doing something like
quatFromTo(toWorldSpace(Q, localFrom), worldTo)*Q
// you should instead consider doing 
align(Q, localFrom, worldTo)

示例

假设您想要四元数 Y，它仅代表 Q 的偏航，即绕 y 轴的纯旋转。 我们可以使用以下代码计算 Y。

Y = align(quat(Qw, Qx, Qy, Qz), vec(0, 1, 0), vec(0, 1, 0))

// simplifies to
Y = normalize(quat(Qw, 0, Qy, 0))

对齐为 4x4 投影矩阵

如果要重复执行相同的对齐操作，因为此操作与将四元数投影到嵌入 4D 空间的 2D 平面上相同，我们可以将此操作表示为与 4x4 投影矩阵的乘法，A*Q。

A = I - leftQ(V)*rightQ(U)/length(U*V)

// which expands to
A = mat4(
    1 + ux*vx + uy*vy + uz*vz, uy*vz - uz*vy, uz*vx - ux*vz, ux*vy - uy*vx,
    uy*vz - uz*vy, 1 + ux*vx - uy*vy - uz*vz, uy*vx + ux*vy, uz*vx + ux*vz,
    uz*vx - ux*vz, uy*vx + ux*vy, 1 - ux*vx + uy*vy - uz*vz, uz*vy + uy*vz,
    ux*vy - uy*vx, uz*vx + ux*vz, uz*vy + uy*vz, 1 - ux*vx - uy*vy + uz*vz)

// A can be applied to Q with the usual matrix-vector multiplication
R = normalize(A*Q)

//LeftQ is a 4x4 matrix which represents the multiplication on the left
//RightQ is a 4x4 matrix which represents the multiplication on the Right
LeftQ(w, x, y, z) = mat4(
    w, -x, -y, -z,
    x,  w, -z,  y,
    y,  z,  w, -x,
    z, -y,  x,  w)

RightQ(w, x, y, z) = mat4(
    w, -x, -y, -z,
    x,  w,  z, -y,
    y, -z,  w,  x,
    z,  y, -x,  w)

I = mat4(
    1, 0, 0, 0,
    0, 1, 0, 0,
    0, 0, 1, 0,
    0, 0, 0, 1)

Answer 6

从算法的角度来看，最快的解决方案是在伪代码中查找

 Quaternion shortest_arc(const vector3& v1, const vector3& v2 ) 
 {
     // input vectors NOT unit
     Quaternion q( cross(v1, v2), dot(v1, v2) );
     // reducing to half angle
     q.w += q.magnitude(); // 4 multiplication instead of 6 and more numerical stable

     // handling close to 180 degree case
     //... code skipped 

        return q.normalized(); // normalize if you need UNIT quaternion
 }

确保您需要单位四元数（通常，插值需要它）。

笔记：
非单位四元数可以用于比单位更快的某些操作。

Answer 7

为什么不使用纯四元数表示向量？ 如果你先将它们标准化也许会更好。
q₁ = (0 u_x u_y u_z)'
q₂ = (0 v_x v_y v_z)'
q₁ q_rot = q₂
预乘 q₁^-1
q_rot = q₁^-1 q₂
其中 q₁^-1 = q₁^conj / q_norm
这可以被认为是“左分裂”。
右除法，这不是你想要的，是：
q_rot,right = q₂^-1 q₁

Answer 8

有些答案似乎没有考虑叉积可能为 0 的可能性。下面的代码片段使用角轴表示：

//v1, v2 are assumed to be normalized
Vector3 axis = v1.cross(v2);
if (axis == Vector3::Zero())
    axis = up();
else
    axis = axis.normalized();

return toQuaternion(axis, ang);

toQuaternion 可以按如下方式实现：

static Quaternion toQuaternion(const Vector3& axis, float angle)
{
    auto s = std::sin(angle / 2);
    auto u = axis.normalized();
    return Quaternion(std::cos(angle / 2), u.x() * s, u.y() * s, u.z() * s);
}

如果您使用的是 Eigen 库，你也可以这样做：

Quaternion::FromTwoVectors(from, to)

Answer 9

为

function fromVectors(u, v) {

  d = dot(u, v)
  w = cross(u, v)

  return Quaternion(d + sqrt(d * d + dot(w, w)), w).normalize()
}

如果已知向量 u 到向量 v 单位向量，该函数简化为

function fromUnitVectors(u, v) {
  return Quaternion(1 + dot(u, v), cross(u, v)).normalize()
}

根据您的用例，可能需要处理点积为 1（平行向量）和 -1（指向相反方向的向量）时的情况。

Answer 10

仅使用归一化四元数，我们可以用以下术语表达约瑟夫·汤普森的答案。

设 q_v = (0, u_x, v_y, v_z) 和 q_w = (0, v_x, v_y, v_z) 并考虑

q = q_v * q_w = (-u dot v, uxv)。

因此将 q 表示为 q(q_0, q_1, q_2, q_3) 我们有

q_r = (1 - q_0, q_1, q_2, q_3).normalize()

Answer 11

@RicharDunlap 是对的：解决方案有无数种。 而说“最小旋转”则不清楚。

但是有一个“规范”四元数，它将归一化向量u映射到归一化向量v。 准确地说，它将通过法向量u原点的平面映射到通过法向量v原点的平面。 这样的描述，可谓是独一无二。

这个四元数是：

re = sqrt((1 + sum(u*v))/2)
w = crossProduct(u, v) / 2 / re
q = (re, w[1], w[2], w[3])