当前位置：首页 > article >正文

Python 实现图形学几何变换算法

article 2024/9/22 21:08:50

Python 实现图形学几何变换算法

在计算机图形学中，几何变换是非常重要的概念。它们允许我们对对象的位置、大小、方向进行操作，比如平移、缩放、旋转、反射等。本文将详细介绍这些几何变换，并使用 Python 结合面向对象编程 (OOP) 的思想进行实现。

几何变换介绍

常见的几何变换包括：

平移 (Translation)：在平面中移动对象。
缩放 (Scaling)：根据某个比例改变对象的大小。
旋转 (Rotation)：围绕某个点对对象进行旋转。
反射 (Reflection)：沿某条轴对对象进行对称反射。
错切 (Shear)：改变对象的形状但保持其体积不变。

这些几何变换都可以通过矩阵运算来描述，并应用于2D图形中的点和向量。

变换矩阵

在二维平面上，变换矩阵可以表示为 3x3 的齐次坐标矩阵。一般的二维变换可以使用下列矩阵表示：

平移矩阵：
$\begin{bmatrix} 1 & 0 & t_x \\ 0 & 1 & t_y \\ 0 & 0 & 1 \end{bmatrix}$
其中， $t_x$ 和 $t_y$ 分别是沿 x 和 y 方向的平移距离。
缩放矩阵：
$\begin{bmatrix} s_x & 0 & 0 \\ 0 & s_y & 0 \\ 0 & 0 & 1 \end{bmatrix}$
其中， $s_x$ 和 $s_y$ 分别是 x 和 y 方向的缩放因子。
旋转矩阵（绕原点逆时针旋转）：
$\begin{bmatrix} \cos\theta & -\sin\theta & 0 \\ \sin\theta & \cos\theta & 0 \\ 0 & 0 & 1 \end{bmatrix}$
其中， $\theta$ 是旋转角度。
反射矩阵（关于 x 轴或 y 轴）：
- 关于 x 轴反射：
  $F_x = \begin{bmatrix} 1 & 0 & 0 \\ 0 & -1 & 0 \\ 0 & 0 & 1 \end{bmatrix}$
- 关于 y 轴反射：
  $F_y = \begin{bmatrix} -1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{bmatrix}$
错切矩阵：
$\begin{bmatrix} 1 & k_x & 0 \\ k_y & 1 & 0 \\ 0 & 0 & 1 \end{bmatrix}$
其中， $k_x$ 和 $k_y$ 分别是 x 和 y 方向的错切因子。

Python 实现几何变换

我们将使用 Python 的面向对象编程思想来实现几何变换类，这样可以更加灵活和可扩展。

import numpy as np

# 定义二维点类
class Point2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def to_homogeneous(self):
        """将点转化为齐次坐标形式"""
        return np.array([self.x, self.y, 1])

    def update_from_homogeneous(self, coords):
        """从齐次坐标更新点的坐标"""
        self.x, self.y = coords[0], coords[1]

# 定义几何变换基类
class Transformation2D:
    def __init__(self):
        self.matrix = np.eye(3)  # 初始化为单位矩阵

    def apply(self, point):
        """将变换应用到一个点上"""
        homogeneous_point = point.to_homogeneous()
        transformed_point = self.matrix.dot(homogeneous_point)
        point.update_from_homogeneous(transformed_point)

# 定义平移变换类
class Translation(Transformation2D):
    def __init__(self, tx, ty):
        super().__init__()
        self.matrix = np.array([
            [1, 0, tx],
            [0, 1, ty],
            [0, 0, 1]
        ])

# 定义缩放变换类
class Scaling(Transformation2D):
    def __init__(self, sx, sy):
        super().__init__()
        self.matrix = np.array([
            [sx, 0, 0],
            [0, sy, 0],
            [0, 0, 1]
        ])

# 定义旋转变换类
class Rotation(Transformation2D):
    def __init__(self, theta):
        super().__init__()
        cos_theta = np.cos(np.radians(theta))
        sin_theta = np.sin(np.radians(theta))
        self.matrix = np.array([
            [cos_theta, -sin_theta, 0],
            [sin_theta, cos_theta, 0],
            [0, 0, 1]
        ])

# 定义反射变换类
class Reflection(Transformation2D):
    def __init__(self, axis):
        super().__init__()
        if axis == 'x':
            self.matrix = np.array([
                [1, 0, 0],
                [0, -1, 0],
                [0, 0, 1]
            ])
        elif axis == 'y':
            self.matrix = np.array([
                [-1, 0, 0],
                [0, 1, 0],
                [0, 0, 1]
            ])

# 定义错切变换类
class Shear(Transformation2D):
    def __init__(self, kx, ky):
        super().__init__()
        self.matrix = np.array([
            [1, kx, 0],
            [ky, 1, 0],
            [0, 0, 1]
        ])

# 使用示例
if __name__ == "__main__":
    # 创建一个二维点
    point = Point2D(1, 1)
    
    # 平移变换
    translation = Translation(2, 3)
    translation.apply(point)
    print(f"After translation: ({point.x}, {point.y})")
    
    # 缩放变换
    scaling = Scaling(2, 2)
    scaling.apply(point)
    print(f"After scaling: ({point.x}, {point.y})")
    
    # 旋转变换
    rotation = Rotation(90)
    rotation.apply(point)
    print(f"After rotation: ({point.x}, {point.y})")
    
    # 反射变换
    reflection = Reflection('x')
    reflection.apply(point)
    print(f"After reflection: ({point.x}, {point.y})")
    
    # 错切变换
    shear = Shear(1, 0)
    shear.apply(point)
    print(f"After shear: ({point.x}, {point.y})")

代码解释

Point2D类：表示一个二维点。该类提供了将点转化为齐次坐标形式的方法，并能从变换后的齐次坐标更新点的坐标。
Transformation2D基类：几何变换的基类，定义了变换矩阵（初始为单位矩阵），并且定义了 apply 方法，用于将变换矩阵作用到一个点上。
具体的几何变换类：如 Translation、Scaling、Rotation、Reflection 和 Shear 类，都继承自 Transformation2D，并分别实现自己的变换矩阵。
使用示例：创建一个二维点，并依次应用平移、缩放、旋转、反射、错切等变换。