Question

这是共同计算翻译和轮换的正确方法，还是有更好的方法？目前我的代码翻译然后旋转，这是否会造成问题？

代码

from math import cos, sin, radians

def trig(angle):
  r = radians(angle)
  return cos(r), sin(r)

def matrix(rotation=(0,0,0), translation=(0,0,0)):
  xC, xS = trig(rotation[0])
  yC, yS = trig(rotation[1])
  zC, zS = trig(rotation[2])
  dX = translation[0]
  dY = translation[1]
  dZ = translation[2]
  return [[yC*xC, -zC*xS+zS*yS*xC, zS*xS+zC*yS*xC, dX],
    [yC*xS, zC*xC+zS*yS*xS, -zS*xC+zC*yS*xS, dY],
    [-yS, zS*yC, zC*yC, dZ],
    [0, 0, 0, 1]]

def transform(point=(0,0,0), vector=(0,0,0)):
  p = [0,0,0]
  for r in range(3):
    p[r] += vector[r][3]
    for c in range(3):
      p[r] += point[c] * vector[r][c]
  return p

if __name__ == '__main__':
  point = (7, 12, 8)
  rotation = (0, -45, 0)
  translation = (0, 0, 5)
  matrix = matrix(rotation, translation)
  print (transform(point, matrix))

输出

root@ubuntu:~$ python rotate.py 
[-0.707106781186547, 12.0, 15.606601717798213]

Answer 1

你的矩阵功能很好我得到它的工作，但对于输出我使用了这个：

#def transform(point, vector):
#  p = [0,0,0]
#  for r in range(0,3):
#    p[r] += vector[r][3]
#    print p
#    for c in range(3):
#        p[r] += point[c] * vector[r][c]
#  return p

def transform(point, TransformArray):
  p = np.array([0,0,0,1])
  for i in range (0,len(point)-1):
      p[i] = point[i]
  p=np.dot(TransformArray,np.transpose(p))
  for i in range (0,len(point)-1):
      point[i]=p[i]
  return point

背后的理论如果不进行手动更改而让矩阵进行排序。在这里您可以找到文献以更好地理解我所做的事情：http://www.inf.ed.ac.uk/teaching/courses/cg/lectures/cg3_2013.pdf

是的，执行矩阵功能的方式定义了执行转换顺序的方式。有三个主要的转换：缩放，翻译和旋转。更多关于我发送的链接。

虽然矩阵函数有效但似乎你错误地交换了x和z旋转现在我现在可以跟随你的任何矩阵索引，所以我重写了它：

def matrix(rotation, translation):
  xC, xS = trig(rotation[0])
  yC, yS = trig(rotation[1])
  zC, zS = trig(rotation[2])
  dX = translation[0]
  dY = translation[1]
  dZ = translation[2]
  Translate_matrix = np.array([[1, 0, 0, dX],
                               [0, 1, 0, dY],
                               [0, 0, 1, dZ],
                               [0, 0, 0, 1]])
  Rotate_X_matrix = np.array([[1, 0, 0, 0],
                              [0, xC, -xS, 0],
                              [0, xS, xC, 0],
                              [0, 0, 0, 1]])
  Rotate_Y_matrix = np.array([[yC, 0, yS, 0],
                              [0, 1, 0, 0],
                              [-yS, 0, yC, 0],
                              [0, 0, 0, 1]])
  Rotate_Z_matrix = np.array([[zC, -zS, 0, 0],
                              [zS, zC, 0, 0],
                              [0, 0, 1, 0],
                              [0, 0, 0, 1]])
  return np.dot(Rotate_Z_matrix,np.dot(Rotate_Y_matrix,np.dot(Rotate_X_matrix,Translate_matrix)))

正如你所看到的，我的回归中的变换序列将改变输出：因为最后一个是平移，它将首先平移点然后在X中旋转，然后在Y中旋转，最后在Z中旋转。希望这有助于欢呼声。

Answer 2

除了matrizes，您可以使用四元数作为替代。它很受欢迎，因为万向节锁定问题不是一个真正的问题，你可以节省比用matrizes更少的内存。然而，取决于你想做什么，它可能在操作上更重。

除此之外，我会说这是一个好方法，也是一个正确的方法。有很多方法可以做到，我认为有很多正确答案......

请记住，转换过程的顺序非常重要，更改顺序可能会产生不同的结果。

Python：转换矩阵

2 个答案: