3D空间中的变换矩阵

3D 空间中的变换矩阵详解

在 3D 计算机图形学中，所有几何变换都可以通过 4×4 齐次变换矩阵 来表示。以下详细介绍各种变换矩阵及其原理。

核心变换矩阵

1. 单位矩阵（不变变换）

$$I=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]$$

2. 平移矩阵（Translation）

将点 $\mathbf{p}=[x,y,z,1{]}^T$ 沿向量 $\mathbf{t}=[t_x,t_y,t_z]$ 移动：

$$T=\left[\begin{array}{cccc}1& 0& 0& t_x\\ 0& 1& 0& t_y\\ 0& 0& 1& t_z\\ 0& 0& 0& 1\end{array}\right]$$

变换后坐标：
$$p^{\prime }=T\cdot p=[x+t_x,y+t_y,z+t_z,1{]}^T$$

T逆矩阵：将 $(t_x,t_y,t_z)$ 取负

3. 缩放矩阵（Scaling）

沿坐标轴缩放，缩放因子 $(s_x,s_y,s_z)$：

$$S=\left[\begin{array}{cccc}{s}_x& 0& 0& 0\\ 0& s_y& 0& 0\\ 0& 0& s_z& 0\\ 0& 0& 0& 1\end{array}\right]$$

特殊类型：

• 均匀缩放：$s_x=s_y=s_z$
• 镜像：某个分量为负（如 $s_x=-1$）
  逆矩阵：使用 $(1/s_x,1/s_y,1/s_z)$（假设因子不为0）。

4. 旋转矩阵（Rotation）

a) 绕坐标轴旋转

旋转方向：右手坐标系中，逆时针为正方向（从旋转轴正向观察）

b) 绕任意轴旋转（Rodrigues公式）

绕单位向量 $\mathbf{u}=[u_x,u_y,u_z]$ 旋转角度 $\theta$：

$$R(\mathbf{u},\theta )=\left[\begin{array}{cccc}\cos \theta +u_x^2(1-\cos \theta )& u_x{u}_y(1-\cos \theta )-u_z\sin \theta & u_x{u}_z(1-\cos \theta )+u_y\sin \theta & 0\\ u_y{u}_x(1-\cos \theta )+u_z\sin \theta & \cos \theta +u_y^2(1-\cos \theta )& u_y{u}_z(1-\cos \theta )-u_x\sin \theta & 0\\ u_z{u}_x(1-\cos \theta )-u_y\sin \theta & u_z{u}_y(1-\cos \theta )+u_x\sin \theta & \cos \theta +u_z^2(1-\cos \theta )& 0\\ 0& 0& 0& 1\end{array}\right]$$

5. 组合变换矩阵

变换矩阵可以通过乘法组合。注意矩阵乘法的顺序非常重要（不满足交换律）。通常，变换按以下顺序应用：缩放 -> 旋转 -> 平移，即：
$$M=T\cdot R\cdot S$$
但是，如果以不同的顺序应用，结果会不同。

例如，先绕Y轴旋转90度，再沿X轴平移3个单位，与先平移后旋转的结果不同：
​​先旋转后平移​​：点会先旋转，然后沿世界坐标系的X轴平移。
​​先平移后旋转​​：点先在世界坐标系中沿X轴平移，然后旋转（此时点的位置已经改变，旋转后位置不同）。

注意顺序：

1. 缩放 (S)
2. 旋转 ®
3. 平移 (T)

这是因为矩阵乘法是 右乘结合：$${\mathbf{p}}^{\prime }=T\cdot (R\cdot (S\cdot \mathbf{p}))$$

特殊变换类型

1. 剪切矩阵（Shear）

$$H=\left[\begin{array}{cccc}1& h_{xy}& h_{xz}& 0\\ h_{yx}& 1& h_{yz}& 0\\ h_{zx}& h_{zy}& 1& 0\\ 0& 0& 0& 1\end{array}\right]$$

2. 正交投影矩阵

向XY平面投影：
$$P_{\text{ortho}}=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 0& 0\\ 0& 0& 0& 0\\ 0& 0& 0& 1\end{array}\right]$$

变换矩阵在编程中的实现

使用GLM（OpenGL Mathematics）库示例(两种写法)

1. GLM函数叠加运算

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

// 初始化矩阵
glm::mat4 model = glm::mat4(1.0f); // 单位矩阵

// 平移：沿X轴移动1.5单位
model = glm::translate(model, glm::vec3(1.5f, 0.0f, 0.0f));

// 旋转：绕Z轴旋转90度
model = glm::rotate(model, glm::radians(90.0f), glm::vec3(0.0f, 0.0f, 1.0f));

// 缩放：Y轴放大2倍
model = glm::scale(model, glm::vec3(1.0f, 2.0f, 1.0f));

变换顺序很重要：矩阵乘法从右到左应用变换，所以上面代码的顺序实际上是先缩放，再旋转，最后平移。
在组合变换时，考虑使用逆序：先进行的变换在矩阵乘法中放在右边（后乘），后进行的变换放在左边（先乘）
2. 计算好各个变换矩阵后再相乘

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform.hpp>

int main() {
    // 单位矩阵
    glm::mat4 identity = glm::mat4(1.0f);
    
    // 平移变换：沿X轴移动2个单位
    glm::mat4 translation = glm::translate(glm::mat4(1.0), glm::vec3(2.0f, 0.0f, 0.0f));
    
    // 缩放变换：Y轴扩大3倍
    glm::mat4 scaling = glm::scale(glm::mat4(1.0), glm::vec3(1.0f, 3.0f, 1.0f));
    
    // 旋转变换：绕Z轴旋转45度
    glm::mat4 rotation = glm::rotate(glm::mat4(1.0), 
                                    glm::radians(45.0f), 
                                    glm::vec3(0.0f, 0.0f, 1.0f));
    
    // 绕任意轴旋转：绕(1,1,0)旋转30度
    glm::vec3 axis = glm::normalize(glm::vec3(1.0f, 1.0f, 0.0f));
    glm::mat4 customRotation = glm::rotate(glm::mat4(1.0), 
                                         glm::radians(30.0f), 
                                         axis);
    
    // 组合变换：先缩放，再旋转，最后平移
    glm::mat4 composite = translation * rotation * scaling;
    
    // 应用变换到点
    glm::vec4 point(1.0f, 1.0f, 0.0f, 1.0f);
    glm::vec4 transformedPoint = composite * point;
    
    return 0;
}

手动实现矩阵类

class Matrix4f {
public:
    float m[4][4];
    
    Matrix4f() { /* 初始化为单位矩阵 */ }
    
    static Matrix4f translate(float tx, float ty, float tz) {
        Matrix4f m;
        m.m[0][3] = tx;
        m.m[1][3] = ty;
        m.m[2][3] = tz;
        return m;
    }
    
    static Matrix4f scale(float sx, float sy, float sz) {
        Matrix4f m;
        m.m[0][0] = sx;
        m.m[1][1] = sy;
        m.m[2][2] = sz;
        return m;
    }
    
    static Matrix4f rotateX(float angle) {
        float rad = angle * M_PI/180.0;
        float c = cos(rad);
        float s = sin(rad);
        
        Matrix4f m;
        m.m[1][1] = c; m.m[1][2] = -s;
        m.m[2][1] = s; m.m[2][2] = c;
        return m;
    }
    
    Matrix4f operator*(const Matrix4f& right) const {
        // 矩阵乘法实现
    }
    
    Vec4f operator*(const Vec4f& v) const {
        // 矩阵向量乘法
    }
};

变换矩阵的性质与应用

1. 齐次坐标

   • 3D点：[x, y, z, 1]ᵀ
   • 3D向量：[x, y, z, 0]ᵀ（防止被平移）

2. 逆变换

   • 平移逆矩阵：$ T^{-1}(t_x, t_y, t_z) = T(-t_x, -t_y, -t_z) $
   • 缩放逆矩阵：$ S^{-1}(s_x, s_y, s_z) = S(1/s_x, 1/s_y, 1/s_z) $
   • 旋转逆矩阵：$ R^{-1} = R^T $（正交矩阵）

3. 组合变换求逆
   组合变换的逆矩阵可以通过矩阵求逆得到。如果变换矩阵是正交的（纯旋转，不含缩放或错切），则转置就是逆矩阵。如果包含平移和缩放，则需要计算逆矩阵：

   $$(T\cdot R\cdot S{)}^{-1}=S^{-1}\cdot R^{-1}\cdot T^{-1}$$
   其中：
   T −1 ：将平移向量取负。
   R −1：旋转矩阵的转置（因为旋转矩阵正交）。
   S −1：缩放因子的倒数（假设非零）。

4. 在变换链中的位置

   局部坐标 → 模型矩阵 → 世界坐标
                ↓
   世界坐标 → 视图矩阵 → 观察坐标
                ↓
   观察坐标 → 投影矩阵 → 裁剪坐标
   

可视化理解变换顺序

考虑一个点 P(0,1,0) 的变换过程：

正确的矩阵乘法顺序：
$$P_{\text{final}}=\underset{\text{平移}}{\underbrace{\left[\begin{array}{cccc}1& 0& 0& 3\\ 0& 1& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]}}\times \underset{\text{旋转}}{\underbrace{\left[\begin{array}{cccc}0& -1& 0& 0\\ 1& 0& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]}}\times \underset{\text{缩放}}{\underbrace{\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 2& 0& 0\\ 0& 0& 1& 0\\ 0& 0& 0& 1\end{array}\right]}}\times \left[\begin{array}{c}0\\ 1\\ 0\\ 1\end{array}\right]$$

这些矩阵构成了 3D 图形学的基础，在 OpenGL、DirectX、Vulkan 等图形 API 以及 Unity、Unreal 等游戏引擎中广泛使用。掌握它们对于理解 3D 渲染管线至关重要。