OpenCV Python3中基于Thin Plate Spline的图像形状转换实现方法

好问题！确实OpenCV的Python绑定里没有直接提供C++中ShapeTransformer那样的现成类来实现Thin Plate Spline（TPS）变换，但我们完全可以手动实现核心逻辑，或者借助OpenCV和SciPy的工具来完成。下面我一步步给你讲清楚具体怎么做：

1. 先搞懂TPS的核心逻辑 #

TPS是一种非线性变换，它能根据两组对应关键点，把源图像平滑扭曲成目标形状，同时尽量保持图像局部的自然纹理。核心步骤是先根据对应点计算出TPS的变换参数矩阵，再用这个矩阵对图像的每个像素做坐标映射。

2. 准备依赖库 #

首先得导入需要的工具：OpenCV负责图像处理，NumPy做矩阵运算，SciPy的线性方程组求解器用来计算TPS参数：

import cv2
import numpy as np
from scipy.linalg import solve

3. 实现TPS的核心函数 #

我们需要两个关键函数：一个计算TPS的变换参数，另一个把参数应用到图像上完成扭曲。

3.1 计算TPS变换参数矩阵 #

def calculate_tps_params(source_pts, target_pts):
    n = source_pts.shape[0]
    # 构造TPS的核心矩阵L
    L = np.zeros((n + 3, n + 3), dtype=np.float64)
    
    # 填充左上角的K子矩阵（TPS的核函数部分）
    for i in range(n):
        for j in range(n):
            dx = source_pts[i, 0] - source_pts[j, 0]
            dy = source_pts[i, 1] - source_pts[j, 1]
            r = np.sqrt(dx**2 + dy**2)
            L[i, j] = 0 if r == 0 else r**2 * np.log(r)
    
    # 填充矩阵的其余部分（线性项和约束）
    L[n:, n:] = 0
    for i in range(n):
        L[i, n] = 1
        L[i, n+1] = source_pts[i, 0]
        L[i, n+2] = source_pts[i, 1]
        L[n, i] = 1
        L[n+1, i] = source_pts[i, 0]
        L[n+2, i] = source_pts[i, 1]
    
    # 构造目标点向量Y
    Y = np.zeros((n + 3, 2), dtype=np.float64)
    Y[:n, 0] = target_pts[:, 0]
    Y[:n, 1] = target_pts[:, 1]
    Y[n:, :] = 0
    
    # 解线性方程组L*W=Y，得到变换参数W
    W = solve(L, Y)
    return W

3.2 应用TPS变换到图像 #

这个函数会遍历目标图像的每个像素，计算它在源图像中的对应位置，再用双线性插值获取像素值，保证图像平滑：

def apply_tps_transform(image, source_pts, target_pts, output_size):
    h, w = output_size
    tps_params = calculate_tps_params(source_pts, target_pts)
    n = source_pts.shape[0]
    output_img = np.zeros((h, w, 3), dtype=np.uint8)
    
    # 遍历目标图像的每个像素，计算其在源图像中的位置
    for y in range(h):
        for x in range(w):
            # 初始化坐标映射值
            u = tps_params[n, 0] + tps_params[n+1, 0] * x + tps_params[n+2, 0] * y
            v = tps_params[n, 1] + tps_params[n+1, 1] * x + tps_params[n+2, 1] * y
            
            # 加上TPS核函数的贡献
            for i in range(n):
                dx = x - source_pts[i, 0]
                dy = y - source_pts[i, 1]
                r = np.sqrt(dx**2 + dy**2)
                if r == 0:
                    continue
                u += tps_params[i, 0] * (r**2 * np.log(r))
                v += tps_params[i, 1] * (r**2 * np.log(r))
            
            # 确保坐标在源图像范围内，避免越界
            u = np.clip(u, 0, image.shape[1]-1)
            v = np.clip(v, 0, image.shape[0]-1)
            
            # 双线性插值获取像素值
            u0, u1 = int(np.floor(u)), min(int(np.ceil(u)), image.shape[1]-1)
            v0, v1 = int(np.floor(v)), min(int(np.ceil(v)), image.shape[0]-1)
            du, dv = u - u0, v - v0
            
            output_img[y, x] = (
                (1-du)*(1-dv)*image[v0, u0] +
                du*(1-dv)*image[v0, u1] +
                (1-du)*dv*image[v1, u0] +
                du*dv*image[v1, u1]
            ).astype(np.uint8)
    
    return output_img

4. 完整示例：把图像从源形状扭成目标形状 #

假设我们要把一张矩形图像扭曲成不规则形状，这里用5个对应关键点做演示：

# 加载源图像
src_img = cv2.imread("your_source_image.jpg")
src_h, src_w = src_img.shape[:2]

# 定义源关键点（比如矩形的四个角+中心）
source_points = np.array([
    [0, 0],
    [src_w-1, 0],
    [src_w-1, src_h-1],
    [0, src_h-1],
    [src_w//2, src_h//2]
], dtype=np.float64)

# 定义目标关键点（扭曲后的形状）
target_points = np.array([
    [50, 20],
    [src_w-60, 30],
    [src_w-20, src_h-40],
    [30, src_h-20],
    [src_w//2 + 30, src_h//2 - 20]
], dtype=np.float64)

# 应用TPS变换，输出大小和源图像一致
result_img = apply_tps_transform(src_img, source_points, target_points, (src_h, src_w))

# 显示结果
cv2.imshow("Source Image", src_img)
cv2.imshow("TPS Transformed Image", result_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

几个实用小贴士 #

• 关键点选得越多，变换的精度越高，但计算速度会变慢，建议选形状的特征点（比如轮廓角点、拐点），至少4个以上才能有效拟合。
• 如果要处理大图像，建议把遍历像素的代码改成NumPy向量化操作，能大幅提升速度，避免嵌套循环的低效。
• 插值方式可以换成最近邻，但双线性插值的平滑效果更好，更适合图像变换场景。

内容的提问来源于stack exchange，提问作者KIRAN