加速OpenCV矩形图像转扇形映射：代码优化方案咨询

问题背景 #

现有尺寸为256×507的矩形输入图像，需映射为1920×1080的扇形图像，映射规则为：

• 输入图像的y值与输出图像的距离成正比
• 输入图像的x值与输出图像相对于中心线的角度成正比

原OpenCV C++逐像素循环代码运行速度较慢，以下提供NumPy向量化和GPU加速两种优化方案。

一、NumPy向量化实现（Python） #

通过NumPy的数组广播机制替代逐像素循环，可大幅提升运算效率，核心思路是一次性计算所有输出像素的映射关系：

import numpy as np
import cv2

def rect_to_sector(my_mat):
    # 输出图像参数
    out_h, out_w = 1080, 1920
    sector_image = np.zeros((out_h, out_w), dtype=np.uint8)
    
    # 原代码固定参数
    cx = 888
    cy = 1080 - 949
    lx = 89
    ly = 1080 - 575
    r = np.sqrt((cx - lx)**2 + (cy - ly)**2)
    pi = np.pi
    half_angle = 65 * pi / 180  # 原代码中的65度偏移
    
    # 生成输出图像坐标网格
    y_grid, x_grid = np.mgrid[0:out_h, 0:out_w]
    
    # 计算每个像素到中心(cx, cy)的距离
    dx = x_grid - cx
    dy = y_grid - cy
    dist = np.sqrt(dx**2 + dy**2)
    
    # 筛选有效区域：dist <= r、y >= cy、px在[lx, rx]范围（rx=1687）
    rx = 1687
    px = r * dx / dist + cx
    valid_mask = (dist <= r) & (y_grid >= cy) & (px >= lx) & (px <= rx)
    
    # 计算有效区域的角度
    vec_center_left = np.array([lx - cx, ly - cy])
    vec_pixel_center = np.array([dx[valid_mask], dy[valid_mask]])
    dot_product = vec_center_left[0] * vec_pixel_center[0] + vec_center_left[1] * vec_pixel_center[1]
    norm_product = np.linalg.norm(vec_center_left) * dist[valid_mask]
    angl = np.arccos(dot_product / norm_product) - half_angle
    
    # 映射到输入图像坐标
    src_y = (dist[valid_mask] / r * my_mat.shape[0]).astype(np.int32)
    src_x = (np.sin(angl) / np.sin(half_angle) * 128 + 127.5).astype(np.int32)
    
    # 边界修正
    src_x = np.clip(src_x, 0, my_mat.shape[1]-1)
    src_y = np.clip(src_y, 0, my_mat.shape[0]-1)
    
    # 赋值到输出图像
    sector_image[valid_mask] = my_mat[src_y, src_x]
    
    return sector_image

# 使用示例
my_mat = cv2.imread("input_rect.png", cv2.IMREAD_GRAYSCALE)
sector_img = rect_to_sector(my_mat)
cv2.imwrite("output_sector.png", sector_img)

优化说明 #

• 用np.mgrid一次性生成所有坐标，避免嵌套循环开销
• 数组广播完成批量计算，速度比逐像素循环快10~100倍（取决于图像尺寸）
• 布尔掩码筛选有效区域，替代逐像素条件判断
• np.clip简化边界修正逻辑，代码更简洁高效

二、GPU加速实现 #

若需进一步提升速度，可借助GPU并行计算能力，以下提供两种常见方案：

方案1：OpenCV CUDA模块（C++/Python） #

利用OpenCV的CUDA加速接口，预先计算映射表后调用cuda::remap完成映射：

// C++ OpenCV CUDA示例
#include <opencv2/cudawarping.hpp>
#include <opencv2/cudaarithm.hpp>

cv::cuda::GpuMat rect_to_sector_gpu(cv::cuda::GpuMat& my_mat_gpu) {
    int out_h = 1080, out_w = 1920;
    cv::cuda::GpuMat map_x(out_h, out_w, CV_32FC1);
    cv::cuda::GpuMat map_y(out_h, out_w, CV_32FC1);
    
    // 批量计算映射表map_x、map_y，逻辑与NumPy版本一致
    // 可通过CUDA核函数或OpenCV CUDA数组操作实现
    
    cv::cuda::GpuMat sector_image_gpu;
    cv::cuda::remap(my_mat_gpu, sector_image_gpu, map_x, map_y, cv::INTER_LINEAR, cv::BORDER_CONSTANT, cv::Scalar(0));
    
    return sector_image_gpu;
}

方案2：PyTorch GPU张量运算 #

将所有计算转移到GPU张量上，利用深度学习框架的自动并行优化：

import torch

def rect_to_sector_torch(my_mat_tensor):
    device = my_mat_tensor.device
    out_h, out_w = 1080, 1920
    sector_image = torch.zeros((out_h, out_w), dtype=torch.uint8, device=device)
    
    cx = 888.0
    cy = (1080 - 949.0)
    lx = 89.0
    ly = (1080 - 575.0)
    r = torch.sqrt((cx - lx)**2 + (cy - ly)**2)
    half_angle = 65 * torch.pi / 180
    
    # 生成坐标网格
    y_grid, x_grid = torch.meshgrid(torch.arange(out_h, device=device), torch.arange(out_w, device=device), indexing='ij')
    dx = x_grid - cx
    dy = y_grid - cy
    dist = torch.sqrt(dx**2 + dy**2)
    
    # 有效区域掩码
    rx = 1687.0
    px = r * dx / dist + cx
    valid_mask = (dist <= r) & (y_grid >= cy) & (px >= lx) & (px <= rx)
    
    # 角度计算
    vec_center_left = torch.tensor([lx - cx, ly - cy], device=device)
    vec_pixel_center = torch.stack([dx[valid_mask], dy[valid_mask]], dim=1)
    dot_product = torch.sum(vec_center_left * vec_pixel_center, dim=1)
    norm_product = torch.norm(vec_center_left) * dist[valid_mask]
    angl = torch.arccos(dot_product / norm_product) - half_angle
    
    # 坐标映射
    src_y = (dist[valid_mask] / r * my_mat_tensor.shape[0]).long()
    src_x = (torch.sin(angl) / torch.sin(half_angle) * 128 + 127.5).long()
    src_x = torch.clamp(src_x, 0, my_mat_tensor.shape[1]-1)
    src_y = torch.clamp(src_y, 0, my_mat_tensor.shape[0]-1)
    
    sector_image[valid_mask] = my_mat_tensor[src_y, src_x]
    return sector_image

# 使用示例
my_mat = cv2.imread("input_rect.png", cv2.IMREAD_GRAYSCALE)
my_mat_tensor = torch.tensor(my_mat, dtype=torch.uint8, device='cuda')
sector_tensor = rect_to_sector_torch(my_mat_tensor)
sector_img = sector_tensor.cpu().numpy()
cv2.imwrite("output_sector_gpu.png", sector_img)

优化说明 #

• GPU方案适合超大规模图像或实时处理场景，速度比CPU向量化快5~20倍
• OpenCV CUDA更适配传统CV场景，PyTorch/TensorFlow适合与深度学习流水线整合

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