透视变换原理

import numpy as np
import math
from PIL import Image
import cv2

def 
affine_transform_numpy(image, transform_matrix, fill_holes=True):
    """

    
使用
numpy
实现仿射变换（正向映射，优化版）

    Args:

        image: 
输入图像的
numpy
数组
 (H, W, C)

        transform_matrix: 2x3
的仿射变换矩阵
        fill_holes: 
是否填充空洞，默认
True

    Returns:

        
变换后的图像
numpy
数组
    """

    h, w, channels = image.shape

    # 
创建输出图像

    output = np.zeros_like(image)

    # 
正向映射：使用原始变换矩阵，完全按照数学公式

    
# [x', y'] = M * [x, y]  (
从原图到目标图
)

    
print("
正向映射变换矩阵
 (2x3):")
    print(transform_matrix)

    # 
优化坐标计算：直接创建坐标矩阵

    
print("
创建坐标网格
...")
    y_indices, x_indices = np.mgrid[0:h, 0:w]

    # 
创建齐次坐标矩阵
 (3, h*w)

    coords = np.vstack([
        x_indices.ravel(),
        y_indices.ravel(), 
        np.ones(h * w, dtype=np.float32)
    ])

    print("
原图像坐标矩阵形状
:", coords.shape)
    print("
前
5
个像素的齐次坐标
:
\n
", coords[:, :5])

    # 
应用正向变换获取目标图像坐标，完全按照原始公式，
@
在
python
中是矩阵乘法

    
# [x', y']^T = M * [x, y, 1]^T

    
print("
计算变换后坐标
...")
    target_coords = transform_matrix @ coords
    target_x = target_coords[0].reshape(h, w)
    target_y = target_coords[1].reshape(h, w)

    print("
变换后坐标范围
:")
    print(f"x': [
{np.min(target_x):
.2f
}
, 
{np.max(target_x):
.2f
}
]")
    print(f"y': [
{np.min(target_y):
.2f
}
, 
{np.max(target_y):
.2f
}
]")

    # 
正向映射：使用向量化操作，大幅提升性能

    
print("
使用向量化操作进行正向映射
...")

    # 
向量化处理：找到所有有效的目标坐标

    valid_mask = ((target_x >= 0) & (target_x < w) & 
                  (target_y >= 0) & (target_y < h))

    # 
获取有效的坐标

    valid_target_x = target_x[valid_mask]
    valid_target_y = target_y[valid_mask]

    # 
四舍五入到整数坐标

    target_x_int = np.round(valid_target_x).astype(int)
    target_y_int = np.round(valid_target_y).astype(int)

    # 
确保坐标在边界内（向量化
clip
操作）

    target_x_int = np.clip(target_x_int, 0, w - 1)
    target_y_int = np.clip(target_y_int, 0, h - 1)

    # 
获取对应的原图像坐标

    y_coords_flat = np.repeat(np.arange(h), w)
    x_coords_flat = np.tile(np.arange(w), h)

    valid_y_orig = y_coords_flat[valid_mask.ravel()]
    valid_x_orig = x_coords_flat[valid_mask.ravel()]

    # 
向量化复制像素值

    
if channels == 1:
        output[target_y_int, target_x_int] = image[valid_y_orig, valid_x_orig]
    else:
        for c in 
range(channels):
            output[target_y_int, target_x_int, c] = image[valid_y_orig, valid_x_orig, c]

    # 
可选的后处理：填补空洞

    
if fill_holes:
        output = fill_holes_simple(output)

    print(f"
变换完成！有效像素比例
: 
{np.sum(output > 0) / output.size * 100
:
.2f
}
%")

    return output.astype(np.uint8)

def 
fill_holes_simple(image):
    """

    
优化的空洞填充算法（向量化实现）

    使用邻域平均值填充空洞（像素值为
0
的位置）
    

    Args:

        image: 
包含空洞的图像
    

    Returns:

        
填充后的图像
    """

    
if np.all(image != 0):
        return image  # 
没有空洞，直接返回

    

    
print("
正在填充空洞
...")
    output = image.copy()
    h, w = image.shape[:2]

    # 
使用卷积进行快速邻域填充

    
from scipy import ndimage

    if 
len(image.shape) == 3:
        channels = image.shape[2]
        for c in 
range(channels):
            channel = image[:, :, c]
            # 
找到空洞位置

            holes = (channel == 0)

            if np.any(holes):
                # 
使用均值滤波填充

                
# 
创建权重矩阵（忽略
0
值）

                weights = (channel > 0).astype(float)

                # 
计算加权平均

                kernel = np.ones((3, 3))
                sum_values = ndimage.convolve(channel.astype(float), kernel, mode='constant')
                sum_weights = ndimage.convolve(weights, kernel, mode='constant')

                # 
避免除以
0

                valid_weights = sum_weights > 0

                filled_values = np.zeros_like(sum_values)
                filled_values[valid_weights] = sum_values[valid_weights] / sum_weights[valid_weights]

                # 
只在空洞位置填充

                output[holes, c] = filled_values[holes]
    else:
        # 
灰度图像

        holes = (image == 0)

        if np.any(holes):
            weights = (image > 0).astype(float)

            kernel = np.ones((3, 3))
            sum_values = ndimage.convolve(image.astype(float), kernel, mode='constant')
            sum_weights = ndimage.convolve(weights, kernel, mode='constant')

            valid_weights = sum_weights > 0

            filled_values = np.zeros_like(sum_values)
            filled_values[valid_weights] = sum_values[valid_weights] / sum_weights[valid_weights]

            output[holes] = filled_values[holes]

    return output

def 
bilinear_interpolation(image, x_coords, y_coords):
    """

    
双线性插值

    Args:

        image: 
单通道图像
 (H, W)

        x_coords: x
坐标数组
        y_coords: y
坐标数组

    Returns:

        
插值后的图像
    """

    h, w = image.shape
    output = np.zeros_like(x_coords)

    # 
找到有效的坐标范围

    valid_mask = (x_coords >= 0) & (x_coords < w - 1) & (y_coords >= 0) & (y_coords < h - 1)

    # 
获取有效坐标

    valid_x = x_coords[valid_mask]
    valid_y = y_coords[valid_mask]

    if 
len(valid_x) == 0:
        return output

    # 
计算整数和小数部分

    x0 = np.floor(valid_x).astype(int)
    y0 = np.floor(valid_y).astype(int)
    x1 = x0 + 1

    y1 = y0 + 1

    
# 
确保坐标在有效范围内

    x1 = np.clip(x1, 0, w - 1)
    y1 = np.clip(y1, 0, h - 1)

    # 
计算权重

    dx = valid_x - x0
    dy = valid_y - y0

    # 
双线性插值

    
# I(x,y) = I(x0,y0)(1-dx)(1-dy) + I(x1,y0)dx(1-dy) + I(x0,y1)(1-dx)dy + I(x1,y1)dxdy

    interpolated = (image[y0, x0] * (1 - dx) * (1 - dy) +
                    image[y0, x1] * dx * (1 - dy) +
                    image[y1, x0] * (1 - dx) * dy +
                    image[y1, x1] * dx * dy)

    output[valid_mask] = interpolated

    return output

def 
create_rotation_matrix(theta):
    """

    
创建旋转变换矩阵
    

    Args:

        theta: 
旋转角度（弧度）
    

    Returns:

        2x3
的旋转矩阵
    """

    cos_theta = math.cos(theta)
    sin_theta = math.sin(theta)

    # 
对应公式中的
2x3
变换矩阵
:

    # [a11  a12  b1]   [cos(θ)   sin(θ)  0]

    # [a21  a22  b2] = [-sin(θ)  cos(θ)  0]

    # 
这是纯旋转矩阵，没有平移分量
 (b1=0, b2=0)

    rotation_matrix = np.array([
        [cos_theta, sin_theta, 0],      # [a11, a12, b1]

        [-sin_theta, cos_theta, 0]      # [a21, a22, b2]

    ], dtype=np.float32)

    return rotation_matrix

def 
create_translation_matrix(tx, ty):
    """

    
创建平移变换矩阵

    Args:

        tx: x
方向平移量
        ty: y
方向平移量

    Returns:

        2x3
的平移矩阵
    """

    translation_matrix = np.array([
        [1, 0, tx],
        [0, 1, ty]
    ], dtype=np.float32)

    return translation_matrix

if __name__ == "__main__":
    try:
        # 
使用
PIL
读取图像

        pil_image = Image.open("/Users/admin/Documents/111.jpeg")
        # 
转换为
numpy
数组

        img = np.array(pil_image)

        if 
len(img.shape) == 3:
            h, w, ch = img.shape
        else:
            # 
如果是灰度图像，添加通道维度

            img = np.expand_dims(img, axis=2)
            h, w, ch = img.shape

        print(f"
图像尺寸
: 
{h}
x
{w}
x
{ch}
")

                # 
创建旋转变换矩阵（逆时针旋转
15
度）

        theta = math.pi / 12  
# 15
度

        rotation_matrix = create_rotation_matrix(theta)

        # 
可以组合多个变换，例如先旋转再平移

        
# translation_matrix = create_translation_matrix(100, 100)

        # combined_matrix = translation_matrix @ np.vstack([rotation_matrix, [0, 0, 1]])

        # transform_matrix = combined_matrix[:2, :]

        

        # 
正向映射：直接使用
2x3
变换矩阵，按照数学公式
 [x', y'] = M * [x, y, 1]

        transform_matrix = rotation_matrix

        print("
变换矩阵
:")
        print(transform_matrix)

        # 
应用仿射变换（正向映射）

        
print("
正在进行仿射变换（正向映射）
...")
        import time
        start_time = time.time()

        # 
可以选择是否填充空洞（填充空洞会增加处理时间）

        fill_holes_option = True  
# 
改为
False
可以跳过空洞填充，提升性能

        transformed_img = affine_transform_numpy(img, transform_matrix, fill_holes=fill_holes_option)

        end_time = time.time()
        print(f"
变换耗时
: 
{end_time - start_time:
.3f
} 
秒
")

        # 
转换图像格式用于
opencv
显示
 (RGB -> BGR)

        
if ch == 3:
            img_bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
            transformed_img_bgr = cv2.cvtColor(transformed_img, cv2.COLOR_RGB2BGR)
        else:
            img_bgr = img
            transformed_img_bgr = transformed_img

        # 
使用
opencv
显示图像

        cv2.namedWindow('Original Image', cv2.WINDOW_NORMAL)
        cv2.namedWindow('Transformed Image', cv2.WINDOW_NORMAL)

        cv2.imshow('Original Image', img_bgr)
        cv2.imshow('Transformed Image', transformed_img_bgr)

        print("
按任意键关闭窗口
...")
        cv2.waitKey(0)
        cv2.destroyAllWindows()

        # 
保存变换后的图像

        output_pil = Image.fromarray(transformed_img)
        output_path = "/Users/admin/Documents/111_transformed.jpeg"

        output_pil.save(output_path)
        print(f"
变换后的图像已保存到
: 
{output_path}
")

    except 
FileNotFoundError:
        print("
错误
: 
找不到图像文件
 /Users/admin/Documents/111.jpeg")
        print("
请确保图像文件存在，或修改文件路径
")
    except 
Exception 
as e:
        print(f"
处理图像时发生错误
: 
{e}
")

透视变换

仿射变换是在二维空间中的旋转、平移和缩放，透视变换是在三维空间中的视角变化。相对于仿射，透视变换能保持”直线性”，原图像中的直线，经透视变换后仍为直线。

如果说仿射变换是对三维空间中某个平面的一些二维变化，透视变换就是对这个平面进行变换，并且利用视觉原理对图像进行一定处理(近大、远小)。