Colour将允许通过还使用更好的感知均匀的色彩空间来做到这一点，例如JzAzBz、Oklab、ICtCp：

import colour
import numpy as np

RGB = np.random.random((256, 256, 3))
colour.plotting.plot_image(RGB);

RGB_f = np.reshape(RGB, (-1, 3))
L = colour.convert(RGB_f, "RGB", "Oklab")[..., 0]
colour.plotting.plot_image(
    colour.utilities.orient(RGB_f[L.argsort()].reshape(RGB.shape), "Flop"));

您也可以将它们显示为网格，如下所示，尽管在更高的分辨率下速度要慢得多：

RGB = np.random.random((64, 64, 3))
RGB_f = np.reshape(RGB, (-1, 3))
L = colour.convert(RGB_f, "RGB", "Oklab")[..., 0]
colour.plotting.plot_multi_colour_swatches(
    RGB_f[L.argsort()], columns=RGB.shape[0], spacing=0.5, background_colour="k");

这里是一个谷歌Colab笔记本，如果你想直接在浏览器中尝试：https://colab.research.google.com/drive/1SD-ZU1clsHgHFyC0gpIP2fK9xBvYX-oS?usp=sharing

我不太明白你的意思。但我的建议是…

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def diag_color(color_df, side):

    colors = np.zeros((side, side, 3))
    
    first = side - 1
    last = - first
    cols, lines = np.meshgrid(range(-side, 0), range(side))
    
    end = 0
    for offset in range(first, last-1, -1):
        
        n = side - abs(offset)
        start = end
        end += n
    
        i = np.diagonal(lines, offset=offset)    
        j = np.diagonal(cols, offset=offset)    
    
        colors[i, j] = color_df.iloc[start:end, :3]

    return colors

def vertic_color(color_df, side, order='C'):
    
    colors = np.zeros((side, side, 3))
    shape = (side, side)
    colors[:,:,0] = color_df['R'].to_numpy().reshape(shape, order=order)
    colors[:,:,1] = color_df['G'].to_numpy().reshape(shape, order=order)
    colors[:,:,2] = color_df['B'].to_numpy().reshape(shape, order=order)
    return colors

您可以使用函数np.flipud，np.fliplr和np.rot90来获取其他图像

desired_no_colors = 5000
side = round(np.sqrt(desired_no_colors))
no_colors = side**2

# Generate colors
color_list = np.random.rand(no_colors, 3)
color_df = pd.DataFrame(color_list, columns=['R', 'G', 'B'])

color_df["HSP"] = (0.299*color_df['R'] + 
                   0.587*color_df['G'] + 
                   0.114*color_df['B'])**0.5

color_df.sort_values('HSP', ascending=False, kind='stable', inplace=True)

c1 = diag_color(color_df, side)
c2 = np.fliplr(c1)

c3 = vertic_color(color_df, side, order='C')
c4 = np.flipud(c3)

c5 = vertic_color(color_df, side, order='F')
c6 = np.fliplr(c5)

fig, ax = plt.subplots(3, 2)
[[ax1, ax2], [ax3, ax4], [ax5, ax6]] = ax

ax1.imshow(c1)
ax2.imshow(c2)
ax3.imshow(c3)
ax4.imshow(c4)
ax5.imshow(c5)
ax6.imshow(c6)

for [a, b] in ax:
    a.set_axis_off()
    b.set_axis_off()

经过几天的挖掘和测试，我想我成功地实现了我想要的，所以我在这里分享我的结果，以防其他人试图做类似的事情。基本上我使用的是代码this文章和this线程的组合。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.collections as collections
from matplotlib.patches import Rectangle

1.生成随机颜色。首先，选择所需的颜色数量，然后获得该数量的四舍五入平方根的幂。这样做可以得到一个整数平方根的数字，以便稍后得到一个完美的WIDTH x HEIGHT网格。

desired_no_colors = 5000
no_colors = round(np.sqrt(desired_no_colors))**2
# Generate colors
color_list = np.array([(np.random.choice(range(256), size=3)) for _ in np.arange(no_colors)])
color_list = color_list / 255 # Convert values to 0-1 range

1.用这个列表创建一个pandas Dataframe
color_df = pd.DataFrame({'color': list(color_list)})
1.定义绘图功能

def plot_color_grid(df):
    width = 1
    height = 1
    nrows = int(df.color.size ** 0.5)
    ncols = int(df.color.size ** 0.5)
    gap = 0.2

    step = width + gap

    x_positions = np.arange(0, ncols*step, step)
    y_positions = np.arange(0, nrows*step, step)

    fig = plt.figure(figsize=(20, 20))
    fig.patch.set_alpha(0)
    ax = plt.subplot(111, aspect='equal')

    ax.axis([0, ncols*step + 1, 0, nrows*step + 1])

    pat = []

    color_index = -1
    for xi in x_positions:
        for yi in y_positions:
            color_index += 1
            sq = Rectangle((yi, xi), width, height, color=df.color[color_index])
            pat.append(sq)

    pc = collections.PatchCollection(pat, match_original=True)
    ax.add_collection(pc)

    plt.axis('off')
    plt.show()

这是我们给pandas dataframe函数的结果：

注意，figsize非常大。如果它更小，行数和列数都很大（在本例中为71），那么一些间隙开始消失或变得大小不一致。这也可以通过调整差距大小、矩形贴片尺寸、用flot数微调 figsize 来解决。
1.向DataFrame中添加一个新列，其中包含HSP计算值。

color_df["HSP"] = color_df.color.apply(lambda x: ((0.299 * x[0]) + (0.587 * x[1]) + (0.114 * x[2])) ** 0.5)

其中“x”显然是元组（R，G，B）
1.最后，我们按照这个新的“HSP”列对值进行排序，并将它们传递给函数

color_df = color_df.sort_values(by=['HSP'], ascending=True, ignore_index=True)

我们得到这个：

在参考文献中，它看起来像这样：