I wrote the two methods below to automatically select N distinct colors. It works by defining a piecewise linear function on the RGB cube. The benefit of this is you can also get a progressive scale if that's what you want, but when N gets large the colors can start to look similar. I can also imagine evenly subdividing the RGB cube into a lattice and then drawing points. Does anyone know any other methods? I'm ruling out defining a list and then just cycling through it. I should also say I don't generally care if they clash or don't look nice, they just have to be visually distinct.
public static List<Color> pick(int num) {
List<Color> colors = new ArrayList<Color>();
if (num < 2)
return colors;
float dx = 1.0f / (float) (num - 1);
for (int i = 0; i < num; i++) {
colors.add(get(i * dx));
}
return colors;
}
public static Color get(float x) {
float r = 0.0f;
float g = 0.0f;
float b = 1.0f;
if (x >= 0.0f && x < 0.2f) {
x = x / 0.2f;
r = 0.0f;
g = x;
b = 1.0f;
} else if (x >= 0.2f && x < 0.4f) {
x = (x - 0.2f) / 0.2f;
r = 0.0f;
g = 1.0f;
b = 1.0f - x;
} else if (x >= 0.4f && x < 0.6f) {
x = (x - 0.4f) / 0.2f;
r = x;
g = 1.0f;
b = 0.0f;
} else if (x >= 0.6f && x < 0.8f) {
x = (x - 0.6f) / 0.2f;
r = 1.0f;
g = 1.0f - x;
b = 0.0f;
} else if (x >= 0.8f && x <= 1.0f) {
x = (x - 0.8f) / 0.2f;
r = 1.0f;
g = 0.0f;
b = x;
}
return new Color(r, g, b);
}
我会尽量把饱和度和亮度调到最大，只关注色调。在我看来，H可以从0到255，然后绕圈。现在如果你想要两种对比色，你可以取这个环的对边，即0和128。如果你想要4种颜色，你需要取一些以圆周长度256的1/4为间隔的颜色，即0,64,128,192。当然，正如其他人建议的那样，当你需要N种颜色时，你可以用256/N将它们分开。
我想补充的是，用二进制数的反向表示来形成这个序列。看看这个:
0 = 00000000 after reversal is 00000000 = 0
1 = 00000001 after reversal is 10000000 = 128
2 = 00000010 after reversal is 01000000 = 64
3 = 00000011 after reversal is 11000000 = 192
.．.
这样，如果你需要N种不同的颜色，你只需要取前N个数字，把它们倒过来，你就能得到尽可能多的距离点(因为N是2的幂)，同时保持序列的每个前缀都有很大不同。
在我的用例中，这是一个重要的目标，因为我有一个图表，其中颜色是根据这种颜色所覆盖的区域进行排序的。我希望图表中最大的区域具有较大的对比度，并且我对一些小区域使用与前十名相似的颜色也没有问题，因为读者通过观察区域就可以很明显地看出哪个是哪个。
这个OpenCV函数使用HSV颜色模型在0<=H<=360º周围生成n个均匀分布的颜色，最大S=1.0, V=1.0。函数在bgr_mat中输出BGR颜色:
void distributed_colors (int n, cv::Mat_<cv::Vec3f> & bgr_mat) {
cv::Mat_<cv::Vec3f> hsv_mat(n,CV_32F,cv::Vec3f(0.0,1.0,1.0));
double step = 360.0/n;
double h= 0.0;
cv::Vec3f value;
for (int i=0;i<n;i++,h+=step) {
value = hsv_mat.at<cv::Vec3f>(i);
hsv_mat.at<cv::Vec3f>(i)[0] = h;
}
cv::cvtColor(hsv_mat, bgr_mat, CV_HSV2BGR);
bgr_mat *= 255;
}
这里有一个解决你的“独特”问题的解决方案，这完全是夸大的:
创建一个单位球体，并在其上放置带有排斥电荷的点。运行一个粒子系统，直到它们不再移动(或者delta“足够小”)。在这一点上，每个点之间的距离都尽可能远。将(x, y, z)转换为rgb。
我提到它是因为对于某些类型的问题，这种类型的解决方案比暴力解决方案更好。
我一开始看到这种方法是用来镶嵌球面的。
同样，遍历HSL空间或RGB空间的最明显的解决方案可能工作得很好。
Janus的回答，但更容易读懂。我还稍微调整了配色方案，并在你可以自己修改的地方做了标记
我已经把这个片段直接粘贴到一个jupyter笔记本。
import colorsys
import itertools
from fractions import Fraction
from IPython.display import HTML as html_print
def infinite_hues():
yield Fraction(0)
for k in itertools.count():
i = 2**k # zenos_dichotomy
for j in range(1,i,2):
yield Fraction(j,i)
def hue_to_hsvs(h: Fraction):
# tweak values to adjust scheme
for s in [Fraction(6,10)]:
for v in [Fraction(6,10), Fraction(9,10)]:
yield (h, s, v)
def rgb_to_css(rgb) -> str:
uint8tuple = map(lambda y: int(y*255), rgb)
return "rgb({},{},{})".format(*uint8tuple)
def css_to_html(css):
return f"<text style=background-color:{css}> </text>"
def show_colors(n=33):
hues = infinite_hues()
hsvs = itertools.chain.from_iterable(hue_to_hsvs(hue) for hue in hues)
rgbs = (colorsys.hsv_to_rgb(*hsv) for hsv in hsvs)
csss = (rgb_to_css(rgb) for rgb in rgbs)
htmls = (css_to_html(css) for css in csss)
myhtmls = itertools.islice(htmls, n)
display(html_print("".join(myhtmls)))
show_colors()
