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;

Answer 2

嗯，这是一种方法。设一个矢量（a，b，c）。求解方程（a，b，c）点（aa，bb，cc）= 0表示aa，bb和cc（并确保aa，bb和cc不全为零），所以（aa，bb，cc））与（a，b，c）正交。我用Maxima（http://maxima.sf.net）来解决它。

(%i42) solve ([a, b, c] . [aa, bb, cc] = 0, [aa, bb, cc]), a=0, b=0;
(%o42)                 [[aa = %r19, bb = %r20, cc = 0]]
(%i43) solve ([a, b, c] . [aa, bb, cc] = 0, [aa, bb, cc]), a=0;
                                        %r21 c
(%o43)              [[aa = %r22, bb = - ------, cc = %r21]]
                                          b
(%i44) solve ([a, b, c] . [aa, bb, cc] = 0, [aa, bb, cc]), b=0;
                             %r23 c
(%o44)              [[aa = - ------, bb = %r24, cc = %r23]]
                               a
(%i45) solve ([a, b, c] . [aa, bb, cc] = 0, [aa, bb, cc]);
                        %r25 c + %r26 b
(%o45)         [[aa = - ---------------, bb = %r26, cc = %r25]]
                               a

请注意，我首先解决了特殊情况（a = 0和b = 0，或a = 0，或b = 0），因为找到的解决方案对于某些等于零的组件并非全部有效。出现的％r变量是任意常量。我将它们设置为1以获得一些特定的解决方案。

(%i52) subst ([%r19 = 1, %r20 = 1], %o42);
(%o52)                    [[aa = 1, bb = 1, cc = 0]]
(%i53) subst ([%r21 = 1, %r22 = 1], %o43);
                                          c
(%o53)                   [[aa = 1, bb = - -, cc = 1]]
                                          b
(%i54) subst ([%r23 = 1, %r24 = 1], %o44);
                                  c
(%o54)                   [[aa = - -, bb = 1, cc = 1]]
                                  a
(%i55) subst ([%r25 = 1, %r26 = 1], %o45);
                                c + b
(%o55)                 [[aa = - -----, bb = 1, cc = 1]]
                                  a

希望这会有所帮助。祝你好运保持良好的工作。

Answer 3

您需要选择一个不等于零的点v，而不是选择与给定单位向量u连接原点的线。

如前所述，您可以在任意轴上选择单位矢量，只要该点满足上述条件即可。如果点u已经位于轴上，则只需为点v选择任何其他轴。

然后你需要解决等式(v + tu).u = 0。（只为t解决）

当然，您需要将其标准化以获得正交单位向量。

enter image description here

Answer 4

这是一个C版本，它使用主导轴来给出更确定的结果。

来电者需要规范化ortho_v3_v3的结果。

inline int axis_dominant_v3_single(const float vec[3])
{
    const float x = fabsf(vec[0]);
    const float y = fabsf(vec[1]);
    const float z = fabsf(vec[2]);
    return ((x > y) ?
           ((x > z) ? 0 : 2) :
           ((y > z) ? 1 : 2));
}

/**
 * Calculates \a p - a perpendicular vector to \a v
 *
 * \note return vector won't maintain same length.
 */
void ortho_v3_v3(float p[3], const float v[3])
{
    const int axis = axis_dominant_v3_single(v);

    assert(p != v);

    switch (axis) {
        case 0:
            p[0] = -v[1] - v[2];
            p[1] =  v[0];
            p[2] =  v[0];
            break;
        case 1:
            p[0] =  v[1];
            p[1] = -v[0] - v[2];
            p[2] =  v[1];
            break;
        case 2:
            p[0] =  v[2];
            p[1] =  v[2];
            p[2] = -v[0] - v[1];
            break;
    }
}

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

[编辑]

4 个答案: