我们在 #python channel 中尝试了很长一段时间如何使用 sympy 从 View 矩阵中计算眼睛/目标/向上向量。一种可能的方法是:

from sympy import *
from pprint import pprint

v1, v2, v3, v4 = symbols('v1 v2 v3 v4')
v5, v6, v7, v8 = symbols('v5 v6 v7 v8')
v9, v10, v11, v12 = symbols('v9 v10 v11 v12')
v13, v14, v15, v16 = symbols('v13 v14 v15 v16')

V = Matrix([
    [v1, v2, v3, v4],
    [v5, v6, v7, v8],
    [v9, v10, v11, v12],
    [v13, v14, v15, v16],
    ])
u1, u2, u3 = symbols('u1 u2 u3', real=True)
t1, t2, t3 = symbols('t1 t2 t3', real=True)
e1, e2, e3 = symbols('e1 e2 e3', real=True)

U = Matrix([u1, u2, u3])
T = Matrix([t1, t2, t2])
E = Matrix([e1, e2, e3])

def calculate_view_matrix(up, eye, target):
    zaxis = (eye - target).normalized()
    xaxis = up.cross(zaxis).normalized()
    yaxis = zaxis.cross(xaxis)

    orientation = Matrix([
        [xaxis[0], yaxis[0], zaxis[0], 0],
        [xaxis[1], yaxis[1], zaxis[1], 0],
        [xaxis[2], yaxis[2], zaxis[2], 0],
        [0, 0, 0, 1],
            ])

    translation = Matrix([
            [1, 0, 0, 0],
            [0, 1, 0, 0],
            [0, 0, 1, 0],
            [-eye[0], -eye[1], -eye[2], 1],
            ])

    return orientation * translation

print(V - calculate_view_matrix(U, E, T))

s = solve([
    V - calculate_view_matrix(U, E, T),
    U.norm() - 1,
    T.norm() - 1],
    [u1, u2, u3, t1, t2, t3, e1, e2, e3])

print(s)

但由于某种原因，该脚本已经运行了约 20 分钟，而 sympy 到目前为止还无法给出任何解决方案。

另一种尝试也试图将上述一般问题简化为更简单的问题，例如如何计算向上向量？

在更简单的上下文中，问题定义应该是这样的:

1. u,z,x 是构成 orthonormal basis 的 3d 向量.
2. z, x 是常数向量
3. u 是未知向量

求解这个的方程式:

u.cross(z).normalized() - x

如果您尝试像这样解决上述通用方程的一个简单特例...

from sympy import *
u1,u2,u3=symbols('u1 u2 u3', real = True)
x=Matrix([1,0,0])
z=Matrix([0,0,1])
u=Matrix([u1,u2,u3])

print(solve(u.cross(z).normalized() - x, u))

你会得到 NotImplementedError: could not solve u2 - Abs(u2)。

NS:事实是，为了从 View 矩阵中提取输入，计算矩阵的函数必须是单射或双射的，否则初始信息将丢失。如果您不添加任何约束，上述函数绝对不是单射的，因为在使用归一化操作的那一刻，该函数自动不再是单射的，例如:

a) normalize(x) = x/|x|
b) To prove normalize is injective then normalize(a)=normalize(b) should give a=b
c) normalize(a)=normalize(b) => a/|a|=b/|b| , which is not true then normalize is not injective

当然，这可以简单地证明只是说无限向量可以提供相同的归一化向量。

这就是为什么向 calculate_view_matrix 添加了一些约束的原因。即:U.norm() - 1，T.norm() - 1。从理论上讲，这应该使 calculate_view_matrix 成为单射的...(或不是 :))

所以主要问题是，如何正确约束/修改 calculate_view_matrix 以便它可以计算出 View 矩阵的眼睛/目标/向上向量？

最佳答案

除了打字错误(T = Matrix([t1, t2, t2]))之外，从 View 矩阵返回的 Ansatz、眼睛和目标向量还有几个缺陷:

• View 矩阵描述了 3D 中的刚性变换，它只有 6 个自由度(3 个轴旋转，3 个轴平移)。这大致意味着 16 个值 v1, v2, ..., v16 中只能选择 6 个(或多或少是任意的)，其他值是相关的或以任何方式确定(例如 v4 = v8 = v12 = 0, v16 = 1, v3**2 = 1 - v1**2 - v2**2, ... ).所以一般来说，矩阵差分的方程是矛盾的。
• 即使在要求 U.norm() - 1 = 0 时，向上矢量 U 也可以取无限多个值(一个角度未确定)。要将 U 的可能解减少到有限多种情况，可以添加条件 U*(E-T) = 0。
• 条件 T.norm() - 1 = 0 是错误的。可以/应该要求长度为 1 的是 T - E(视角方向)。

总而言之，我没有找到修复 Ansatz s.t. 的方法。 U, E, T 可以使用方程式和 sympy 从 View 矩阵计算。但是 U, E, T 可以很容易地从 View 矩阵中提取出来:

• 可以从第二列读取规范化的U(满足上述要求)
• -E可以从最后一行开始读取
• 可以从第三列读取归一化 View 向量E - T

在 sympy/Python 代码中:

def calculate_up_eye_target(viewMat):
  eye = -viewMat[3,0:3].T
  target = eye - viewMat[0:3,2]
  up = viewMat[0:3,1]
  return up, eye, target

关于python - 如何使用 sympy 从 View 矩阵中提取眼睛/目标/向上？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43706865/