如何应用变换矩阵？

Question

我试图获取 3D 空间中某个点的 2D 屏幕坐标，即我知道摄像机的平移、倾斜和滚动位置，并且我有我希望投影的点的 3D x、y、z 坐标。

我很难理解变换/投影矩阵，我希望这里的一些聪明人可以帮助我；）

这是我迄今为止整理的测试代码：

public class TransformTest {

public static void main(String[] args) {

    // set up a world point (Point to Project)
    double[] wp = {100, 100, 1};
    // set up the projection centre (Camera Location)
    double[] pc = {90, 90, 1};

    double roll = 0;
    double tilt = 0;
    double pan = 0;

    // translate the point
    vSub(wp, pc, wp);

    // create roll matrix
    double[][] rollMat = {
            {1, 0, 0},
            {0, Math.cos(roll), -Math.sin(roll)},
            {0, Math.sin(roll), Math.cos(roll)},
    };
    // create tilt matrix
    double[][] tiltMat = {
            {Math.cos(tilt), 0, Math.sin(tilt)},
            {0, 1, 0},
            {-Math.sin(tilt), 0, Math.cos(tilt)},
    };
    // create pan matrix
    double[][] panMat = {
            {Math.cos(pan), -Math.sin(pan), 0},
            {Math.sin(pan), Math.cos(pan), 0},
            {0, 0, 1},
    };

    // roll it
    mvMul(rollMat, wp, wp);
    // tilt it
    mvMul(tiltMat, wp, wp);
    // pan it
    mvMul(panMat, wp, wp);

}

public static void vAdd(double[] a, double[] b, double[] c) {
    for (int i=0; i<a.length; i++) {
        c[i] = a[i] + b[i];
    }
}

public static void vSub(double[] a, double[] b, double[] c) {
    for (int i=0; i<a.length; i++) {
        c[i] = a[i] - b[i];
    }      
}

public static void mvMul(double[][] m, double[] v, double[] w) {

    // How to multiply matrices?
} }

基本上，我需要的是获取给定的 2D XY 坐标3D 点相交的屏幕。 我不知道如何使用滚动、倾斜和平移矩阵来变换世界点（wp）。

非常感谢任何帮助！

Answer 1

这是很复杂的事情。 请阅读一本有关该主题的书，以了解所有数学和基本细节。 如果你打算长期使用这些东西，你需要了解这些事情。 这个答案只是为了让你可以先实践一下。

矩阵相乘

首先要做的事情。 矩阵相乘是一件相当简单的事情。

假设您有矩阵 A、B 和 C，其中 AB = C >。 假设您想计算出矩阵 C 第 3 行第 2 列的值。

• 取 A 的第三行和 B 的第二列嗯>。 现在，A 和 B 中的值数量应该相同。 （如果你没有为这两个矩阵定义矩阵乘法。你不能这样做。）如果两个都是 4×4 矩阵，你应该有来自 A 的 4 个值（第 3 行） ）和来自 B 的 4 个值（第 2 列）。
• 将 A 的每个值与 B 的每个值相乘。 您最终应该得到 4 个新值。
• 添加这些值。

现在，您已在第 3 行第 2 列处获得了矩阵 C 的值。当然，挑战在于以编程方式执行此操作。

/* AB = C

Row-major ordering
a[0][0] a[0][2] a[0][3]...
a[1][0] a[1][4] ...
a[2][0] ...
...*/
public static mmMul(double[][] a, double[][] b, double[][] c) {
    c_height = b.length; // Height of b
    c_width = a[0].length; // Width of a
    common_side = a.length; // Height of a, width of b

    for (int i = 0; i < c_height; i++) {
        for (int j = 0; j < c_width; j++) {
            // Ready to calculate value of c[i][j]
            c[i][j] = 0;

            // Iterate through ith row of a, jth col of b in lockstep
            for (int k = 0; k < common_side; k++) {
                c[i][j] += a[i][k] * b[k][j];
            }
        }
    }
}

---

齐次坐标

您有 3D 坐标。 假设您有 (5, 2, 1)。 这些是笛卡尔坐标。 我们称它们为（x、y、z）。

齐次坐标意味着您在笛卡尔坐标末尾额外写入 1。 (5,2,1) 变为 (5,2,1,1)。 我们称它们为（x、y、z、w）。

每当您进行使 w ≠ 1 的转换时，您都将坐标的每个分量除以 w。 这会更改您的 x、y 和 z，并且再次使 w = 1。 （即使你的变换没有改变 w，这样做也没有坏处。它只是将所有内容除以 1，什么也不做。）

你可以使用同质坐标做一些非常酷的事情，即使它们背后的数学并不完全有意义。 正是在这一点上，我要求您再次查看此答案顶部的建议。

---

转变一点

我将在本节和以下各节中使用 OpenGL 术语和方法。 如果有任何不清楚或似乎与您的目标相冲突（因为这对我来说似乎有点像家庭作业：P），请发表评论。

我还将首先假设您的滚动、倾斜和平移矩阵是正确的。

当您想要使用变换矩阵来变换点时，可以将该矩阵与表示该点的列向量右乘。 假设您想通过某个变换矩阵 A 来平移 (5, 2, 1)。 您首先定义v = [5, 2, 1, 1]^T。 （我用 [x、y、z、w]^T 写小 T 表示您应该将其写为列向量。）

// Your point in 3D
double v[4][5] = {{5}, {2}, {1}, {1}}

在这种情况下，Av = v ₁，其中v₁是你的变换点。 像矩阵乘法一样执行此乘法，其中 A 为 4×4，v 为 4×1。 您最终将得到一个 4×1 矩阵（这是另一个列向量）。

// Transforming a single point with a roll
double v_1[4][6];
mmMul(rollMat, v, v_1);

现在，如果您要应用多个变换矩阵，请首先将它们组合成一个变换矩阵。 通过按照您希望应用的顺序将矩阵相乘来实现此目的。

从编程角度来说，您应该从单位矩阵开始，然后对每个变换矩阵进行右乘。 令 I₄ 为 4×4 单位矩阵，并令 A₁, A₂, A₃, ... 是您的变换矩阵。 让你的最终变换矩阵为 A_final

A_final ← I ₄
A_最终 ← A_最终 A₁< br>
A_最终 ← A_最终 A₂< br>
A_最终 ← A_最终 A₃< br>

请注意，我使用该箭头来表示赋值。 当您实现此操作时，请确保在矩阵乘法计算中仍在使用 A_final 时不要覆盖它！ 复制一份。

// A composite transformation matrix (roll, then tilt)

double a_final[4][4] =
{
    {1, 0, 0, 0},
    {0, 1, 0, 0},
    {0, 0, 1, 0},
    {0, 0, 0, 1}
}; // the 4 x 4 identity matrix

double a_final_copy[4][4];
mCopy(a_final, a_final_copy); // make a copy of a_final
mmMul(rollMat, a_final_copy, a_final);
mCopy(a_final, a_final_copy); // update the copy
mmMul(tiltMat, a_final_copy, a_final);

最后，进行与上面相同的乘法：A_final v = v ₁

// Use the above matrix to transform v
mmMul(a_final, v, v_1);

---

从开始到结束

相机变换应该表示为视图矩阵。 在此执行 A_view v = v₁ 操作。 （v 将您的世界坐标表示为 4×1 列向量，A_final 是您的 A _view。）

// World coordinates to eye coordinates
// A_view is a_final from above
mmMult(a_view, v_world, v_view);

投影变换描述了透视变换。 这就是使较近的物体变大而使较远的物体变小的原因。 这是在相机变换之后执行的。 如果您还不需要透视，只需使用单位矩阵作为投影矩阵即可。 不管怎样，在这里执行 A v₁ = v₂ 。

// Eye coordinates to clip coordinates
// If you don't care about perspective, SKIP THIS STEP
mmMult(a_projection, v_view, v_eye);

接下来，您需要进行视角划分。 这更深入地研究了同质坐标，我还没有描述过。 无论如何，将 v₂ 的每个分量除以 v₂ 的最后一个分量。 如果v₂ = [x，y，z，w ]^T，然后将每个分量除以w（包括w本身）。 你最终应该得到 w = 1。（如果你的投影矩阵是单位矩阵，就像我之前描述的那样，这一步应该什么都不做。）

// Clip coordinates to normalized device coordinates
// If you skipped the previous step, SKIP THIS STEP
for (int i = 0; i < 4; i++) {
    v_ndc[i] = v_eye[i] / v[3];
}

最后，取你的 v <子>2。 前两个坐标是您的 x 和 y 坐标。 第三个是z，你可以扔掉它。 （稍后，一旦您变得非常高级，您可以使用此 z 值来确定哪个点位于其他点的前面或后面。）此时，最后一个组件是 w = 1，所以你根本不再需要它了。

x = v_ndc[0]
y = v_ndc[1]
z = v_ndc[2]  // unused; your screen is 2D

如果您跳过了透视图和透视图划分步骤，请使用 v_view 而不是上面的 v_ndc。

这与 OpenGL 坐标系。 不同之处在于，您从世界坐标开始，而 OpenGL 从对象坐标开始。 区别如下：

• 您从世界坐标开始
  • OpenGL 从对象坐标开始
• 你使用视图矩阵将世界坐标转换为眼睛坐标
  • OpenGL 使用 ModelView 矩阵将对象坐标转换为眼睛坐标

从那时起，一切都是一样的。

Answer 2

这个范围太大了，无法在这里得到一个好的答案：我建议阅读有关该主题的很好的参考资料。 我一直很喜欢 Foley 和 VanDam...

Answer 3

我在此处发布了一些代码，可以满足您的大部分需求。

它包含 OpenGL gluPerspective() 和 gluLookAt() 函数的 Java 实现：

Camera camera = new Camera();

Point3d eye = new Point3d(3, 4, 8);
Point3d center = new Point3d(0, 0, 0);
Vector3d up = new Vector3d(0, 1, 0);

camera.perspective(60.0, 1.6, 0.1, 20); // vertical fov, aspect ratio, znear, zfar
camera.lookAt(eye, center, up);

要使用其中的 project() 函数，请使用

void plot(Camera camera, Point4d p) {
    Point4d q = Camera.project(p);
    float x = q.x / q.w;
    float y = q.y / q.w;
    ...
}

：返回的 code>x 和 y 值在 -0.5 ... 0.5 范围内