使用Numba njit并行处理时Colormath与Numpy报错排查

错误根源 #

你遇到的Untyped global name 'process': Cannot determine Numba type of <class 'function'>错误，核心有两个问题：

1. 未编译函数调用：Numba的JIT编译器无法识别未被@nb.jit装饰的process函数，它无法推断未编译函数的类型信息。
2. 非兼容库依赖：process函数中使用的colormath库（sRGBColor、LCHabColor、convert_color）都是纯Python对象/方法，Numba仅兼容numpy数值计算、基础Python语法和部分内置函数，不支持这类面向对象操作。

分步解决方案 #

1. 修正基础笔误 #

先修复代码中的变量错误：create_image里的process(pixel)改为process(p)，否则会报未定义变量错误。

2. 替换colormath为Numba兼容的颜色转换逻辑 #

由于Numba无法处理colormath的类和方法，最优方案是用纯numpy/Numba兼容代码实现RGB↔LCHab的标准转换：

import numba as nb
import numpy as np

# sRGB转XYZ
@nb.jit(nopython=True)
def rgb_to_xyz(r, g, b):
    r_norm = r / 255.0
    g_norm = g / 255.0
    b_norm = b / 255.0

    def gamma_correct(x):
        return ((x + 0.055) / 1.055) ** 2.4 if x > 0.04045 else x / 12.92

    r_linear = gamma_correct(r_norm)
    g_linear = gamma_correct(g_norm)
    b_linear = gamma_correct(b_norm)

    x = r_linear * 0.4124564 + g_linear * 0.3575761 + b_linear * 0.1804375
    y = r_linear * 0.2126729 + g_linear * 0.7151522 + b_linear * 0.0721750
    z = r_linear * 0.0193339 + g_linear * 0.1191920 + b_linear * 0.9503041
    return x, y, z

# XYZ转Lab
@nb.jit(nopython=True)
def xyz_to_lab(x, y, z):
    x_n, y_n, z_n = 0.95047, 1.0, 1.08883

    def f(t):
        return t ** (1/3) if t > 0.008856 else 7.787 * t + 16/116

    l = 116 * f(y / y_n) - 16
    a = 500 * (f(x / x_n) - f(y / y_n))
    b = 200 * (f(y / y_n) - f(z / z_n))
    return l, a, b

# Lab转LCHab
@nb.jit(nopython=True)
def lab_to_lch(l, a, b):
    c = np.sqrt(a**2 + b**2)
    h = np.arctan2(b, a) * (180 / np.pi)
    if h < 0:
        h += 360
    return l, c, h

# LCHab转Lab
@nb.jit(nopython=True)
def lch_to_lab(l, c, h):
    h_rad = h * (np.pi / 180)
    a = c * np.cos(h_rad)
    b = c * np.sin(h_rad)
    return l, a, b

# Lab转XYZ
@nb.jit(nopython=True)
def lab_to_xyz(l, a, b):
    x_n, y_n, z_n = 0.95047, 1.0, 1.08883

    def f_inv(t):
        return t ** 3 if t > 0.206893 else (t - 16/116) / 7.787

    y = y_n * f_inv((l + 16) / 116)
    x = x_n * f_inv((l + 16)/116 + a/500)
    z = z_n * f_inv((l + 16)/116 - b/200)
    return x, y, z

# XYZ转sRGB
@nb.jit(nopython=True)
def xyz_to_rgb(x, y, z):
    r_linear = x * 3.2404542 + y * -1.5371385 + z * -0.4985314
    g_linear = x * -0.9692660 + y * 1.8760108 + z * 0.0415560
    b_linear = x * 0.0556434 + y * -0.2040259 + z * 1.0572252

    def gamma_inv(x):
        return 1.055 * (x ** (1/2.4)) - 0.055 if x > 0.0031308 else 12.92 * x

    r = max(0, min(1, gamma_inv(r_linear))) * 255
    g = max(0, min(1, gamma_inv(g_linear))) * 255
    b = max(0, min(1, gamma_inv(b_linear))) * 255
    return int(r), int(g), int(b)

3. 重写核心处理函数 #

给process和func2加上@nb.jit(nopython=True)装饰，调整并行循环的使用（仅外层用prange更高效）：

# 确保func2兼容Numba
@nb.jit(nopython=True)
def func2(h, foo_array):
    diff = np.abs(foo_array - h)
    idx = np.argmin(diff)
    # 替换为你的实际逻辑
    return idx * 0.1, foo_array[idx]

@nb.jit(nopython=True)
def process(p, e, f, foo_array):
    r, g, b = p[0], p[1], p[2]
    # RGB转LCHab
    x, y, z = rgb_to_xyz(r, g, b)
    l, a, b_lab = xyz_to_lab(x, y, z)
    l, c, h = lab_to_lch(l, a, b_lab)

    # 自定义处理逻辑
    c_factor, h_offset = func2(h, foo_array)
    c *= c_factor
    h += h_offset

    # 坐标变换
    c1 = c
    h1 = h * (np.pi / 180)
    x_pos = c1 * np.cos(h1) + e
    y_pos = c1 * np.sin(h1) + f

    c_new = np.sqrt(x_pos**2 + y_pos**2)
    angle = np.arctan2(y_pos, x_pos) * (180 / np.pi)
    if angle < 0:
        angle += 360
    h_new = angle

    # LCHab转回RGB
    l_new, a_new, b_new = lch_to_lab(l, c_new, h_new)
    x_new, y_new, z_new = lab_to_xyz(l_new, a_new, b_new)
    r_mod, g_mod, b_mod = xyz_to_rgb(x_new, y_new, z_new)

    return (r_mod, g_mod, b_mod)

@nb.jit(parallel=True)
def create_image(img_array, e, f, foo_array):
    img_array_c = np.copy(img_array)
    row, col = img_array_c.shape[:2]

    # 仅外层用prange并行，避免嵌套并行的线程开销
    for r in nb.prange(row):
        for c in range(col):
            p = img_array_c[r, c]
            p_mod = process(p, e, f, foo_array)
            img_array_c[r, c] = p_mod

    return img_array_c

4. 关键注意事项 #

• 所有被Numba编译的函数必须仅使用Numba支持的语法：优先用numpy函数，避免纯Python对象、类方法、第三方库的非数值API。
• nopython=True是Numba的最优模式，强制生成纯机器码，避免回退到解释执行，确保性能最大化。
• 并行循环尽量只在外层使用，嵌套prange可能导致线程开销过大，反而降低效率。

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