Question

我在Autodesk Maya中使用Python编写一个函数（使用PyMel for Maya）

我有三个3D点; p0，p1，p2。

然后他们进行了严格的转变，所以在转变（仿射变换）后，我有了新的职位; q0，q1，q2。

我在变革前还有第四点; P3。我想在同样的转变后计算它的位置; Q4。

所以我需要计算变换矩阵，然后将其应用到p4。我不知道该怎么做。 List =一个对象数组

import pymel.core as pm
import pymel.core.datatypes as dt

p0 = dt.Vector(pm.getAttr(list[0]+".tx"), pm.getAttr(list[0]+".ty"), pm.getAttr(list[0]+".tz"))
p1 = dt.Vector(pm.getAttr(list[1]+".tx"), pm.getAttr(list[1]+".ty"), pm.getAttr(list[1]+".tz"))
p2 = dt.Vector(pm.getAttr(list[2]+".tx"), pm.getAttr(list[2]+".ty"), pm.getAttr(list[2]+".tz")
p3 = dt.Vector(pm.getAttr(list[3]+".tx"), pm.getAttr(list[3]+".ty"), pm.getAttr(list[3]+".tz"))

从Maya场景中的动画对象中读取3D点。所以在另一个框架，我运行此代码来获取

q0 = dt.Vector(pm.getAttr(list[0]+".tx"), pm.getAttr(list[0]+".ty"), pm.getAttr(list[0]+".tz"))
q1 = dt.Vector(pm.getAttr(list[1]+".tx"), pm.getAttr(list[1]+".ty"), pm.getAttr(list[1]+".tz"))
q2 = dt.Vector(pm.getAttr(list[2]+".tx"), pm.getAttr(list[2]+".ty"), pm.getAttr(list[2]+".tz"))
#q3 = TransformationMatrix between (p0,p1,p2) and (q0,q1,q2), applied to p3

我试图用向量计算，但由于零除以后我得到了错误... 所以我认为转换矩阵可以毫无问题地解决它。

我有一个不远处的截止日期，我真的需要帮助解决这个问题！请帮助！

编辑： how to perform coordinates affine transformation using python?

我需要这个函数“solve_affine”，但每组只需要3分而不是4分。而且我不能使用numpy ......

Answer 1

这是一个使用numpy和scipy的解决方案。 scipy主要用于生成随机旋转，除了scipy.linalg.norm，它很容易编码自己。 numpy使用的主要内容是交叉乘法和矩阵乘法，它们也很容易编码。

基本思想是：给定三个非共线点x1，x2，x3，可以找到正交的三个向量（轴）v1，v2，v3，其中v1在x2的方向上-x1，v2在跨越（x2-x1）和（x3-x1）的平面中，v3完成三次。

点y1，y2，y3相对于x1，x2，x3旋转和平移。从y1，y2，y3产生的轴w1，w2，w3从v1，v2，v3旋转（即，没有平移）。这两组三元组各自是正交的，因此很容易找到它们的旋转：R = W * transpose(V)

完成轮换后，查找翻译很简单：y1 = R*x + t，t = y1 - R*x。使用最小二乘解算器并将所有三个点组合起来得到t的估计值可能更好。

import numpy
import scipy.linalg


def rand_rot():
    """Return a random rotation

    Return a random orthogonal matrix with determinant 1"""
    q, _ = scipy.linalg.qr(numpy.random.randn(3, 3))
    if scipy.linalg.det(q) < 0:
        # does this ever happen?
        print "got a negative det"
        q[:, 0] = -q[:, 0]
    return q


def rand_noncollinear():
    """Return 3 random non-collinear vectors"""
    while True:
        b = numpy.random.randn(3, 3)
        sigma = scipy.linalg.svdvals(b)
        if sigma[2]/sigma[0] > 0.1:
            # "very" non-collinear
            break
        # "nearly" collinear; try again

    return b[:, 0], b[:, 1], b[:, 2]


def normalize(a):
    """Return argument normalized"""
    return a/scipy.linalg.norm(a)


def colstack(a1, a2, a3):
    """Stack three vectors as columns"""
    return numpy.hstack((a1[:, numpy.newaxis],
                         a2[:, numpy.newaxis],
                         a3[:, numpy.newaxis]))


def get_axes(a1, a2, a3):
    """Generate orthogonal axes from three non-collinear points"""
    # I tried to do this with QR, but something didn't work
    b1 = normalize(a2-a1)
    b2 = normalize(a3-a1)
    b3 = normalize(numpy.cross(b1, b2))
    b4 = normalize(numpy.cross(b3, b1))
    return b1, b4, b3

# random rotation and translation
r = rand_rot()
t = numpy.random.randn(3)

# three non-collinear points
x1, x2, x3 = rand_noncollinear()
# some other point
x4 = numpy.random.randn(3)

# the images of the above in the transformation.
# y4 is for checking only -- won't be used to estimate r or t
y1, y2, y3, y4 = [numpy.dot(r, x) + t
                  for x in x1, x2, x3, x4]


v1, v2, v3 = get_axes(x1, x2, x3)
w1, w2, w3 = get_axes(y1, y2, y3)

V = colstack(v1, v2, v3)
W = colstack(w1, w2, w3)

# W = R V, so R = W * inverse(V); but V orthogonal, so inverse(V) is
# transpose(V):
rfound = numpy.dot(W, V.T)

# y1 = R x1 + t, so...
tfound = y1-numpy.dot(r, x1)

# get error on images of x2 and x3, just in case

y2err = scipy.linalg.norm(numpy.dot(rfound, x2) + tfound - y2)
y3err = scipy.linalg.norm(numpy.dot(rfound, x3) + tfound - y3)

# and check error image of x4 -- getting an estimate of y4 is the
# point of all of this
y4err = scipy.linalg.norm(numpy.dot(rfound, x4) + tfound - y4)

print "y2 error: ", y2err
print "y3 error: ", y3err
print "y4 error: ", y4err

Answer 2

描述和代码都令人困惑。描述有点模糊，而代码示例缺少重要的部分。所以这就是我理解这个问题的方法：

知道两个空间中的三个点如何构建从空间A到空间B的变换？

two spaces transformed

图片1 ：如何在2个空格之间形成转换。

答案取决于空间的变换类型。您会看到三个点始终形成平面跨度。这意味着您可以知道新空间的旋转，变换和统一比例是什么。您还可以知道平面上的剪切以及非均匀刻度。但是，您无法知道平面法线方向上的剪切或非均匀尺度。

因此，有意义的是，问题变成了如何旋转和翻译两个空格以匹配？这很容易做翻译部分直接：

trans = q0 - p0

这让你有了轮换，已在几篇文章中解释过：

您也可以在此之后计算缩放系数。

Answer 3

我已经弄明白了

p0p1 = p1-p0
p0p2 = p2-p0
p0p3 = p3-p0

q0q1 = q1-q0
q0q2 = q2-q0
q0q3 = q3-q0

before = dt.Matrix([p0.x, p0.y, p0.z, 0],[p1.x, p1.y, p1.z, 0],[p2.x, p2.y, p2.z, 0], [0,0,0,1]);
after = dt.Matrix([q0.x, q0.y, q0.z, 0],[q1.x, q1.y, q1.z, 0],[q2.x, q2.y, q2.z, 0], [0,0,0,1]);

normal = p0p1.cross(p0p2).normal()
dist = p0p3.dot(normal)
q3 = p3 - dist*normal

transformMatrix = before.inverse()*after
solve = dt.Matrix(q3.x, q3.y, q3.z, 1)*transformMatrix

q3 =  dt.Vector(solve[0][0], solve[0][1], solve[0][2])

newNormal = q0q1.cross(q0q2).normal()
q3 = q3 + newNormal*dist

pm.move(list[3], q3, r=False)

转换矩阵仅适用于平面p0p1p2内的点。所以我通过改变p3的投影点来解决它，然后将它从平面移出相同的距离。

如果您的解决方案只涉及矩阵，请随时分享，它可能仍然对我有帮助！：）

Python中的仿射3D变换

3 个答案: