基于颜色映射表的PNG图像/视频高效平滑重着色方案咨询

高效替代方案 #

1. Numpy向量化运算替代逐像素循环 #

现有代码的性能瓶颈在于PIL逐像素遍历的Python循环，改用numpy对整个图像数组做批量运算，可将单图处理时间压缩至毫秒级。利用numpy的广播机制，一次性完成所有像素的多项式计算，彻底规避Python层面的循环开销。

2. OpenCV + CUDA GPU加速（视频场景首选） #

针对视频批量处理需求，使用OpenCV的CUDA模块将计算转移至GPU，性能可提升数倍至数十倍。二次多项式运算可通过CUDA核函数或cv::cuda::transform实现全量批量处理，完全满足实时视频处理的要求。

3. 预计算颜色查找表（LUT） #

由于RGB值范围固定为0-255，总共有约1670万种颜色组合，可预先计算所有输入RGB对应的输出RGB值，生成3D查找表。处理图像时直接通过查表获取结果，单图处理速度仅受内存读写限制，是最高效的方案之一。

非命令行工具的优势 #

• 灵活性更强：可自定义复杂着色逻辑（如二次多项式映射），不受ffmpeg等命令行工具的预设表达式语法限制
• 调试与扩展成本低：可直接在代码中添加日志、调整算法参数，还能对接机器学习、专业图像处理库（如scikit-image、PyTorch）实现更复杂的优化
• 性能可控性高：可根据硬件环境选择numpy、CUDA、多线程等不同加速方案，而命令行工具的优化空间相对有限

优化代码示例 #

Numpy向量化版本 #

from PIL import Image
import numpy as np

def return_row(r, g, b):
    r_inv = 255 - r
    g_inv = 255 - g
    b_inv = 255 - b
    return [r_inv**2, g_inv**2, b_inv**2, r_inv * g_inv, g_inv * b_inv, b_inv * r_inv, r_inv, g_inv, b_inv]

def solve_mat(dictionary):
    A = []
    B = []
    for color_code in dictionary.values():
        r, g, b = color_code[:3]
        value = color_code[3]
        row = return_row(r, g, b)
        A.append(row)
        B.append(value)
    X = np.linalg.lstsq(A, B, rcond=None)[0]
    return X

def get_individual_channel_dict(color_change_dict):
    r_dict = {}
    g_dict = {}
    b_dict = {}
    for color, array in color_change_dict.items():
        r_dict[color] = array[:3] + [array[3]]
        g_dict[color] = array[:3] + [array[4]]
        b_dict[color] = array[:3] + [array[5]]
    return r_dict, g_dict, b_dict

def get_coeff_mat(r_dict, g_dict, b_dict):
    r_mat = solve_mat(r_dict)
    g_mat = solve_mat(g_dict)
    b_mat = solve_mat(b_dict)
    return r_mat, g_mat, b_mat

def rgb_out_vec(R, G, B, param_mat):
    a, b, c, d, e, f, g, h, i = param_mat
    return (a * (R**2) + b * (G**2) + c * (B**2) +
            d * R * G + e * G * B + f * B * R +
            g * R + h * G + i * B).astype(np.uint8)

def change_colors_in_one_image(image_path):
    with Image.open(image_path) as img:
        img_arr = np.array(img)
        R, G, B = img_arr[..., 0], img_arr[..., 1], img_arr[..., 2]
        
        new_R = rgb_out_vec(R, G, B, r_mat)
        new_G = rgb_out_vec(R, G, B, g_mat)
        new_B = rgb_out_vec(R, G, B, b_mat)
        
        new_img_arr = np.stack([new_R, new_G, new_B], axis=-1)
        new_img = Image.fromarray(new_img_arr)
        new_img.save(image_path)

# 自定义颜色映射规则
color_change_dict = {
    "white": [5, 98, 255, 240, 240, 240],
    "black": [255, 255, 255, 81, 92, 93],
    "red": [207, 54, 108, 52, 152, 219],
    "mud": [203, 103, 14, 203, 103, 14],
}

r_dict, g_dict, b_dict = get_individual_channel_dict(color_change_dict)
r_mat, g_mat, b_mat = get_coeff_mat(r_dict, g_dict, b_dict)
change_colors_in_one_image("input.png")

预计算LUT版本（适合批量/视频处理） #

# 预计算全RGB范围的查找表
lut_r = np.zeros((256, 256, 256), dtype=np.uint8)
lut_g = np.zeros((256, 256, 256), dtype=np.uint8)
lut_b = np.zeros((256, 256, 256), dtype=np.uint8)

for r in range(256):
    for g in range(256):
        for b in range(256):
            lut_r[r, g, b] = rgb_out_vec(r, g, b, r_mat)
            lut_g[r, g, b] = rgb_out_vec(r, g, b, g_mat)
            lut_b[r, g, b] = rgb_out_vec(r, g, b, b_mat)

# 基于LUT的图像快速处理
def change_colors_with_lut(image_path):
    with Image.open(image_path) as img:
        img_arr = np.array(img)
        new_R = lut_r[img_arr[...,0], img_arr[...,1], img_arr[...,2]]
        new_G = lut_g[img_arr[...,0], img_arr[...,1], img_arr[...,2]]
        new_B = lut_b[img_arr[...,0], img_arr[...,1], img_arr[...,2]]
        new_img_arr = np.stack([new_R, new_G, new_B], axis=-1)
        new_img = Image.fromarray(new_img_arr)
        new_img.save(image_path)

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