使用向上向量查看四元数

Question

我有一个相机（在自定义 3D 引擎中）接受四元数进行旋转变换。我有两个 3D 点代表相机和要查看的对象。我想计算从相机到物体的四元数，同时尊重世界上轴。

This question 在没有 "up" 向量的情况下要求相同的东西。所有三个答案都会导致相机指向正确的方向，但会滚动（如 yaw/pitch/roll 中；想象在看东西时将头靠在耳朵上）。

我可以通过以下方式计算与所需坐标系匹配的向量的正交基：

lookAt = normalize(target - camera)
sideaxis = cross(lookAt, worldUp)
rotatedup = cross(sideaxis, lookAt)

如何从这三个向量创建四元数？ This question 要求同样的事情...但不幸的是，唯一被接受的答案是 ~"let's assume you don't care about roll"，然后忽略上轴。我确实关心滚动。我不想忽略上轴。

Answer 1

看着侧轴向上旋转

如果将这 3 个向量归一化，则它是旋转矩阵 3x3 的一个分量。所以只需将这个旋转矩阵转换为四元数即可。

Answer 2

假设您最初有三个正交向量：worldUp、worldFront 和 worldSide，让我们将您的方程式用于 lookAt、sideAxis 和 rotatedUp。 worldSide 向量将不是实现结果所必需的。

将操作一分为二。首先，围绕 worldUp 旋转。然后围绕 sideAxis 旋转，它现在实际上与旋转后的 worldSide 平行。

Axis1 = worldUp
Angle1 = (see below)

Axis2 = cross(lookAt, worldUp) = sideAxis
Angle2 = (see below)

这些旋转中的每一个都对应于一个四元数，使用：

Q = cos(Angle/2) + i * Axis_x * sin(Angle/2) + j * Axis_y * sin(Angle/2) + k * Axis_z * sin(Angle/2)

将 Q1 和 Q2 相乘即可得到所需的四元数。

角度详情：

令 P(worldUp) 为 worldUp 方向的投影矩阵，即 P(worldUp).v = cos(worldUp,v).worldUp 或使用 kets 和 bras，P(worldUp) = |worldUp > < 世界|。让我成为单位矩阵。

在垂直于 worldUp 的平面中投影 lookAt 并将其归一化。

tmp1 = (I - P(worldUp)).lookAt
n1 = normalize(tmp1)
Angle1 = arccos(点(worldFront,n1))
Angle2 = arccos(dot(lookAt,n1))

编辑 1：

请注意，无需计算超越函数。由于一对归一化向量的点积是角度的余弦，假设 cos(t) = x，我们有三角恒等式：

cos(t/2) = sqrt((1 + x)/2)
sin(t/2) = sqrt((1 - x)/2)

Answer 3

之前的回答给出了使用角度的有效解决方案。此答案将提供另一种方法。

正交基向量，重命名为F = lookAt, R = sideaxis, U = rotatedup，直接形成3x3旋转矩阵的列，相当于你想要的四元数：

与矢量相乘等同于使用所述矢量的分量作为相机基础中的坐标。

可以将 3x3 旋转矩阵转换为四元数 ，而无需 转换为角度/使用昂贵的三角函数。下面是一个数值稳定的 C++ 片段，它返回一个规范化的四元数：

inline void CalculateRotation( Quaternion& q ) const {
  float trace = a[0][0] + a[1][1] + a[2][2];
  if( trace > 0 ) {
    float s = 0.5f / sqrtf(trace + 1.0f);
    q.w = 0.25f / s;
    q.x = ( a[2][1] - a[1][2] ) * s;
    q.y = ( a[0][2] - a[2][0] ) * s;
    q.z = ( a[1][0] - a[0][1] ) * s;
  } else {
    if ( a[0][0] > a[1][1] && a[0][0] > a[2][2] ) {
      float s = 2.0f * sqrtf( 1.0f + a[0][0] - a[1][1] - a[2][2]);
      q.w = (a[2][1] - a[1][2] ) / s;
      q.x = 0.25f * s;
      q.y = (a[0][1] + a[1][0] ) / s;
      q.z = (a[0][2] + a[2][0] ) / s;
    } else if (a[1][1] > a[2][2]) {
      float s = 2.0f * sqrtf( 1.0f + a[1][1] - a[0][0] - a[2][2]);
      q.w = (a[0][2] - a[2][0] ) / s;
      q.x = (a[0][1] + a[1][0] ) / s;
      q.y = 0.25f * s;
      q.z = (a[1][2] + a[2][1] ) / s;
    } else {
      float s = 2.0f * sqrtf( 1.0f + a[2][2] - a[0][0] - a[1][1] );
      q.w = (a[1][0] - a[0][1] ) / s;
      q.x = (a[0][2] + a[2][0] ) / s;
      q.y = (a[1][2] + a[2][1] ) / s;
      q.z = 0.25f * s;
    }
  }
}

来源：http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion

将其转换为适合您的情况当然只是将矩阵元素与相应的向量分量交换：

// your code from before
F = normalize(target - camera);   // lookAt
R = normalize(cross(F, worldUp)); // sideaxis
U = cross(R, F);                  // rotatedup

// note that R needed to be re-normalized
// since F and worldUp are not necessary perpendicular
// so must remove the sin(angle) factor of the cross-product
// same not true for U because dot(R, F) = 0

// adapted source
Quaternion q;
double trace = R.x + U.y + F.z;
if (trace > 0.0) {
  double s = 0.5 / sqrt(trace + 1.0);
  q.w = 0.25 / s;
  q.x = (U.z - F.y) * s;
  q.y = (F.x - R.z) * s;
  q.z = (R.y - U.x) * s;
} else {
  if (R.x > U.y && R.x > F.z) {
    double s = 2.0 * sqrt(1.0 + R.x - U.y - F.z);
    q.w = (U.z - F.y) / s;
    q.x = 0.25 * s;
    q.y = (U.x + R.y) / s;
    q.z = (F.x + R.z) / s;
  } else if (U.y > F.z) {
    double s = 2.0 * sqrt(1.0 + U.y - R.x - F.z);
    q.w = (F.x - R.z) / s;
    q.x = (U.x + R.y) / s;
    q.y = 0.25 * s;
    q.z = (F.y + U.z) / s;
  } else {
    double s = 2.0 * sqrt(1.0 + F.z - R.x - U.y);
    q.w = (R.y - U.x) / s;
    q.x = (F.x + R.z) / s;
    q.y = (F.y + U.z) / s;
    q.z = 0.25 * s;
  }
}

（不用说交换 y 和 z 如果您使用的是 OpenGL。）

使用向上向量查看四元数

Look-at quaternion using up vector

quaternions