如何使用sympy从视图矩阵中提取眼睛/目标/向上？-Java 学习之路

我们试图在 #python Channels 中弄清楚如何使用sympy从视图矩阵中计算眼睛/目标/向上矢量 . 一种可行的方法可能是：

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还没有给出任何解决方案 .

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

在更简单的上下文中，问题定义将是这样的：

u,z,x 是3d向量，形成orthonormal basis .
z, x 是常量向量
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：为了从视图矩阵中提取输入，需要比计算矩阵的函数是内射或双射的，否则初始信息将丢失 . 如果你没有添加任何约束，上面的函数肯定不是内射函数，因为在使用规范化操作的那一刻，函数不再是自动的，例如：

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

当然，这可以简单地证明只是说infinitelly向量可以提供相同的标准化向量 .

这就是为什么 calculate_view_matrix 增加了一些限制的原因 . 即： U.norm() - 1 ， T.norm() - 1 . 理论上，这应该授予 calculate_view_matrix 成为单射......（或不:)

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

1 回答

1
除了拼写错误（ T = Matrix([t1, t2, t2]) ）之外，您的Ansatz中还有一些缺陷，即从视图矩阵中恢复，眼睛和目标向量：
- 视图矩阵描述了3D中的刚性变换，其仅具有6个自由度（3个轴旋转，3个轴平移） . 这大致意味着16个值中只有6个 v1, v2, ..., v16 可以选择（或多或少任意），其他值依赖或以任何方式确定（例如 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 . 但是 U, E, T 可以很容易地从视图矩阵中提取：

可以从第二列读取
- 标准化的 U （满足上述要求）
- -E 可以从最后一行读取
- 可以从第三列读取标准化视图向量 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
```
回复于 2024-05-06T20:37:03+08:00

如何使用sympy从视图矩阵中提取眼睛/目标/向上？

1 回答

相关问题