问题：

我已经使用一些循环定义了自己的色彩空间（黄-蓝），并希望使用一些后处理过滤器将标准HD图像从RGB实时转换为YB，但我编写的方法执行此有利任务的速度较慢。

上下文：

我想知道狗会看到什么颜色，结果发现它们分不清绿色和红色：

所以我决定定义我自己的YB色彩空间，如下图所示：

∮ ∮ ∮ ∮ ∮一个月一个月

bits = 8
values = 2 ** bits - 1
color_count = values * 6

def hues():
    lst = []
    for i in range(color_count):
        r = g = b = 0

        turn = (i // values) + 1

        if turn == 1:
            r = values
            g = i % values
            b = 0

        elif turn == 2:
            r = values - i % values
            g = values
            b = 0

        elif turn == 3:
            r = 0
            g = values
            b = i % values

        elif turn == 4:
            r = 0
            g = values - i % values
            b = values

        elif turn == 5:
            r = i % values
            g = 0
            b = values

        elif turn == 6:
            r = values
            g = 0
            b = values - i % values

        r = round(r / values * 255)
        g = round(g / values * 255)
        b = round(b / values * 255)

        lst.append((r, g, b))

    return lst

def dues():
    lst = []
    for i in range(color_count):
        r = g = b = 0

        turn = (i // values) + 1

        if turn == 1:
            r = values
            g = values
            b = round((values - i % values) / 2)

        elif turn == 2:
            r = values
            g = values
            b = round((i % values) / 2)

        elif turn == 3:
            if i % values < values / 2:
                r = values
                g = values
                b = round((values / 2 + i % values))
            else:
                r = round((3 / 2 * values - i % values))
                g = round((3 / 2 * values - i % values))
                b = values

        elif turn == 4:
            r = round((values - i % values) / 2)
            g = round((values - i % values) / 2)
            b = values

        elif turn == 5:
            r = round((i % values) / 2)
            g = round((i % values) / 2)
            b = values

        elif turn == 6:
            if i % values < values / 2:
                r = round((values / 2 + i % values))
                g = round((values / 2 + i % values))
                b = values
            else:
                r = values
                g = values
                b = round((3 / 2 * values - i % values))

        r = round(r / values * 255)
        g = round(g / values * 255)
        b = round(b / values * 255)

        lst.append((r, g, b))

    return lst

def rgb_to_hsl(color: tuple):
    r, g, b = color

    r /= 255
    g /= 255
    b /= 255

    cmax = max(r, g, b)
    cmin = min(r, g, b)
    delta = cmax - cmin

    h = 0
    l = (cmax + cmin) / 2

    if delta == 0:
        h = 0
    elif cmax == r:
        h = ((g - b) / delta) % 6
    elif cmax == g:
        h = ((b - r) / delta) + 2
    elif cmax == b:
        h = ((r - g) / delta) + 4

    h *= 60

    if delta == 0:
        s = 0
    else:
        s = delta / (1 - abs(2 * l - 1))

    return h, s, l

def hsl_to_rgb(color: tuple):
    h, s, l = color

    c = (1 - abs(2 * l - 1)) * s
    x = c * (1 - abs((h / 60) % 2 - 1))
    m = l - c / 2

    r = g = b = 0

    if 0 <= h < 60:
        r = c
        g = x
    elif 60 <= h < 120:
        r = x
        g = c
    elif 120 <= h < 180:
        g = c
        b = x
    elif 180 <= h < 240:
        g = x
        b = c
    elif 240 <= h < 300:
        r = x
        b = c
    elif 300 <= h < 360:
        r = c
        b = x

    r = round((r + m) * 255)
    g = round((g + m) * 255)
    b = round((b + m) * 255)

    return r, g, b

在保存列表值时，我获得了预期的色调：

现在，主要处理包括按以下顺序逐个像素地转换颜色：
1.获取RGB

1. RGB--〉HSL
   1.将色调值更改为dues_hsl列表中的相应值
   1.新建HSL--〉RGB
   1.在另一个数组中的相同坐标处设置新的RGB值
   对图像中的每个像素重复该过程，并且在尺寸为481 x 396像素的测试图像上花费大约58秒

输入和输出：

一个四个一个一个一个五个一个
相同代码：

defining.py

from PIL import Image
import numpy as np
from calculating import hues, dues
from calculating import rgb_to_hsl as hsl
from calculating import hsl_to_rgb as rgb

hues = hues()
dues = dues()

# Hues = human hues
# Dues = dog hues

hues_hsl = [hsl(i) for i in hues]
dues_hsl = [hsl(i) for i in dues]

img = np.array(Image.open('dog.png').convert('RGB'))

arr_blank = np.zeros(img.shape[0:3])
print(arr_blank.shape)
print(img.shape[0:3])

total = img.shape[0] * img.shape[1]

for i in range(img.shape[0]):
    for j in range(img.shape[1]):
        hsl_val = hsl(tuple(img[i, j]))
        h = dues_hsl[hues_hsl.index(min(hues_hsl, key=lambda x: abs(x[0] - hsl_val[0])))][0]
        pixel = np.array(rgb((h, hsl_val[1], hsl_val[2])))
        arr_blank[i, j, :] = pixel

        print(f'{i * img.shape[1] + j} / {total}  ---  {(i * img.shape[1] + j)/total*100} %')

print(arr_blank)
data = Image.fromarray(arr_blank.astype('uint8'), 'RGB')
data.save('dog_color.png')

结论：

在这之后，我想添加一个高斯模糊过滤器，实时转换后，但这是需要很长的时间才一帧。有什么办法可以提高速度？

机器信息：

如果此信息有帮助：i7 - 10750H@2.6Ghz，固态硬盘，16 GB内存
谢谢!