math - 给定一个任意单位向量，计算任意正交单位向量的最佳方法是什么？

Question

基本上问了同样的问题here ，但在非编程环境中。建议的解决方案是采用 { y, -x, 0 }。这适用于所有具有 x 或 y 分量的向量，但如果向量等于 + 或 - { 0, 0, 1 } 则失败。在这种情况下，我们会得到 { 0, 0, 0 }。

我目前的解决方案(在 C++ 中):

// floating point comparison utilizing epsilon
bool is_equal(float, float);

// ...

vec3 v = /* some unit length vector */

// ...

// Set as a non-parallel vector which we will use to find the 
//   orthogonal vector. Here we choose either the x or y axis.
vec3 orthog;
if( is_equal(v.x, 1.0f) )
  orthog.set(1.0f, 0.0f, 0.0f);
else
  orthog.set(0.0f, 1.0f, 0.0f);

// Find orthogonal vector
orthog = cross(v, orthog);
orthog.normalize(); 

这个方法可行，但我觉得可能有更好的方法，我的搜索没有更多结果。

---

[编辑]

只是为了好玩，我用 C++ 快速编写了每个建议答案的简单实现代码，并验证它们都有效(尽管有些并不总是自然地返回单位向量，我在需要的地方添加了 noramlize() 调用).

我最初的想法:

vec3 orthog_peter(vec3 const& v)
{
  vec3 arbitrary_non_parallel_vec = v.x != 1.0f ? vec3(1.0, 0.0f, 0.0f) : vec3(0.0f, 1.0f, 0.0f);
  vec3 orthog = cross(v, arbitrary_non_parallel_vec);

  return normalize( orthog );
}

https://stackoverflow.com/a/19650362/2507444

vec3 orthog_robert(vec3 const& v)
{
  vec3 orthog;
  if(v.x == 0.0f && v.y == 0.0f)
    orthog = vec3(1.0f, 1.0f, 0.0f);
  else if(v.x == 0.0f)
    orthog = vec3(1.0f, v.z / v.y, 1.0f);
  else if(v.y == 0.0f)
    orthog = vec3(-v.z / v.x, 1.0f, 1.0f);
  else
    orthog = vec3(-(v.z + v.y) / v.x, 1.0f, 1.0f);

  return normalize(orthog);
}

https://stackoverflow.com/a/19651668/2507444

// NOTE: u and v variable names are swapped from author's example
vec3 orthog_abhishek(vec3 const& v)
{
  vec3 u(1.0f, 0.0f, 0.0f);
  float u_dot_v = dot(u, v);

  if(abs(u_dot_v) != 1.0f)
    return normalize(u + (v * -u_dot_v));
  else
    return vec3(0.0f, 1.0f, 0.0f);
}

https://stackoverflow.com/a/19658055/2507444

vec3 orthog_dmuir(vec3 const& v)
{
  float length = hypotf( v.x, hypotf(v.y, v.z));
  float dir_scalar = (v.x > 0.0) ? length : -length;
  float xt = v.x + dir_scalar;
  float dot = -v.y / (dir_scalar * xt);

  return vec3(
    dot * xt, 
    1.0f + dot * v.y, 
    dot * v.z);
};

Answer 1

另一种方法是使用 Householder reflectors .

我们可以找到一个反射器 Q，将我们的向量映射到 (1,0,0) 的倍数。将 Q 应用于 (0,1,0) 将得到一个垂直于我们向量的向量。这种方法的一个优点是它适用于任意数量的维度；另一个是我们可以获得垂直于原始向量和新向量的其他向量:将 Q 应用于 (0,0,1)。这听起来可能很复杂，但这是 3d 的 C 代码(xp、yp、zp 是必需的向量，长度为 1；如所写，所有内容都是 double ，但您可以使用 float 代替，并使用 hypotf 代替 hypot)

l = hypot( x, hypot(y,z));
s = (x > 0.0) ? l : -l;
xt = x + s;
dot = -y/(s*xt);
xp = dot*xt;
yp = 1.0 + dot*y;
zp = dot*z;