N個の「異なる」色を自動的に生成する方法
N個の異なる色を自動的に選択するために、以下の2つのメソッドを作成しました。 RGBキューブで区分線形関数を定義することにより機能します。これの利点は、必要に応じてプログレッシブスケールを取得できることですが、Nが大きくなると色が似たように見えるようになります。また、RGBキューブを格子状に均等に分割し、ポイントを描画することも想像できます。誰か他の方法を知っていますか？リストを定義してから、リストを循環するだけです。また、それらが衝突したりニースに見えたりするかどうかは一般的に気にしないと言ってください。視覚的に区別する必要があります。
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);
}
HSLカラーモデル を使用して、色を作成できます。
必要なものが色相の違い（おそらく）と、明度または彩度のわずかな変化だけである場合、次のように色相を分配できます。
// assumes hue [0, 360), saturation [0, 100), lightness [0, 100)
for(i = 0; i < 360; i += 360 / num_colors) {
HSLColor c;
c.hue = i;
c.saturation = 90 + randf() * 10;
c.lightness = 50 + randf() * 10;
addColor(c);
}
この質問は、かなりの数のSOディスカッションに表示されます。
さまざまなソリューションが提案されていますが、最適なものはありません。幸いなことに、scienceが助けになります
任意のN
- カテゴリ画像の色表示 （無料ダウンロード）
- マップの色付けをパーソナライズするWebサービス （無料ダウンロード、Webサービスソリューションは来月までに利用可能になるはずです）
- ハイコントラストカラーセットの選択のためのアルゴリズム （著者は無料のC++実装を提供しています）
- 色のハイコントラストセット （問題の最初のアルゴリズム）
最後の2つは、ほとんどの大学図書館/プロキシ経由で無料になります。
Nは有限で比較的小さい
この場合、リストソリューションを選択できます。主題の非常に興味深い記事は自由に利用できます：
考慮すべきいくつかのカラーリストがあります。
- ほとんど混乱しない、ボイントンの11色のリスト（前のセクションの最初の論文で利用可能）
- ケリーの22色の最大コントラスト（上記の論文で入手可能）
また、MITの学生が this Paletteに遭遇しました。最後に、次のリンクは、異なるカラーシステム/座標間の変換に役立つ場合があります（たとえば、記事の一部の色はRGBで指定されていません）。
- http://chem8.org/uch/space-55036-do-blog-id-5333.html
- https://metacpan.org/pod/Color::Library::Dictionary::NBS_ISCC
- 色理論：マンセルHVCをRGB/HSB/HSLに変換する方法
ケリーとボイントンのリストについては、すでにRGBへの変換を行っています（白と黒は例外ですが、これは明らかです）。いくつかのC＃コード：
public static ReadOnlyCollection<Color> KellysMaxContrastSet
{
get { return _kellysMaxContrastSet.AsReadOnly(); }
}
private static readonly List<Color> _kellysMaxContrastSet = new List<Color>
{
UIntToColor(0xFFFFB300), //Vivid Yellow
UIntToColor(0xFF803E75), //Strong Purple
UIntToColor(0xFFFF6800), //Vivid Orange
UIntToColor(0xFFA6BDD7), //Very Light Blue
UIntToColor(0xFFC10020), //Vivid Red
UIntToColor(0xFFCEA262), //Grayish Yellow
UIntToColor(0xFF817066), //Medium Gray
//The following will not be good for people with defective color vision
UIntToColor(0xFF007D34), //Vivid Green
UIntToColor(0xFFF6768E), //Strong Purplish Pink
UIntToColor(0xFF00538A), //Strong Blue
UIntToColor(0xFFFF7A5C), //Strong Yellowish Pink
UIntToColor(0xFF53377A), //Strong Violet
UIntToColor(0xFFFF8E00), //Vivid Orange Yellow
UIntToColor(0xFFB32851), //Strong Purplish Red
UIntToColor(0xFFF4C800), //Vivid Greenish Yellow
UIntToColor(0xFF7F180D), //Strong Reddish Brown
UIntToColor(0xFF93AA00), //Vivid Yellowish Green
UIntToColor(0xFF593315), //Deep Yellowish Brown
UIntToColor(0xFFF13A13), //Vivid Reddish Orange
UIntToColor(0xFF232C16), //Dark Olive Green
};
public static ReadOnlyCollection<Color> BoyntonOptimized
{
get { return _boyntonOptimized.AsReadOnly(); }
}
private static readonly List<Color> _boyntonOptimized = new List<Color>
{
Color.FromArgb(0, 0, 255), //Blue
Color.FromArgb(255, 0, 0), //Red
Color.FromArgb(0, 255, 0), //Green
Color.FromArgb(255, 255, 0), //Yellow
Color.FromArgb(255, 0, 255), //Magenta
Color.FromArgb(255, 128, 128), //Pink
Color.FromArgb(128, 128, 128), //Gray
Color.FromArgb(128, 0, 0), //Brown
Color.FromArgb(255, 128, 0), //Orange
};
static public Color UIntToColor(uint color)
{
var a = (byte)(color >> 24);
var r = (byte)(color >> 16);
var g = (byte)(color >> 8);
var b = (byte)(color >> 0);
return Color.FromArgb(a, r, g, b);
}
そして、16進および8ビット/チャネル表示のRGB値は次のとおりです。
kelly_colors_hex = [
0xFFB300, # Vivid Yellow
0x803E75, # Strong Purple
0xFF6800, # Vivid Orange
0xA6BDD7, # Very Light Blue
0xC10020, # Vivid Red
0xCEA262, # Grayish Yellow
0x817066, # Medium Gray
# The following don't work well for people with defective color vision
0x007D34, # Vivid Green
0xF6768E, # Strong Purplish Pink
0x00538A, # Strong Blue
0xFF7A5C, # Strong Yellowish Pink
0x53377A, # Strong Violet
0xFF8E00, # Vivid Orange Yellow
0xB32851, # Strong Purplish Red
0xF4C800, # Vivid Greenish Yellow
0x7F180D, # Strong Reddish Brown
0x93AA00, # Vivid Yellowish Green
0x593315, # Deep Yellowish Brown
0xF13A13, # Vivid Reddish Orange
0x232C16, # Dark Olive Green
]
kelly_colors = dict(vivid_yellow=(255, 179, 0),
strong_purple=(128, 62, 117),
vivid_orange=(255, 104, 0),
very_light_blue=(166, 189, 215),
vivid_red=(193, 0, 32),
grayish_yellow=(206, 162, 98),
medium_gray=(129, 112, 102),
# these aren't good for people with defective color vision:
vivid_green=(0, 125, 52),
strong_purplish_pink=(246, 118, 142),
strong_blue=(0, 83, 138),
strong_yellowish_pink=(255, 122, 92),
strong_Violet=(83, 55, 122),
vivid_orange_yellow=(255, 142, 0),
strong_purplish_red=(179, 40, 81),
vivid_greenish_yellow=(244, 200, 0),
strong_reddish_brown=(127, 24, 13),
vivid_yellowish_green=(147, 170, 0),
deep_yellowish_brown=(89, 51, 21),
vivid_reddish_orange=(241, 58, 19),
dark_olive_green=(35, 44, 22))
すべてのJava開発者向けに、JavaFXの色を以下に示します。
// Don't forget to import javafx.scene.Paint.Color;
private static final Color[] KELLY_COLORS = {
Color.web("0xFFB300"), // Vivid Yellow
Color.web("0x803E75"), // Strong Purple
Color.web("0xFF6800"), // Vivid Orange
Color.web("0xA6BDD7"), // Very Light Blue
Color.web("0xC10020"), // Vivid Red
Color.web("0xCEA262"), // Grayish Yellow
Color.web("0x817066"), // Medium Gray
Color.web("0x007D34"), // Vivid Green
Color.web("0xF6768E"), // Strong Purplish Pink
Color.web("0x00538A"), // Strong Blue
Color.web("0xFF7A5C"), // Strong Yellowish Pink
Color.web("0x53377A"), // Strong Violet
Color.web("0xFF8E00"), // Vivid Orange Yellow
Color.web("0xB32851"), // Strong Purplish Red
Color.web("0xF4C800"), // Vivid Greenish Yellow
Color.web("0x7F180D"), // Strong Reddish Brown
Color.web("0x93AA00"), // Vivid Yellowish Green
Color.web("0x593315"), // Deep Yellowish Brown
Color.web("0xF13A13"), // Vivid Reddish Orange
Color.web("0x232C16"), // Dark Olive Green
};
以下は、上記の順序に従って並べ替えられていないケリー色です。
以下は色相に従ってソートされたケリー色です（いくつかの黄色はあまり対照的ではないことに注意してください）
Uri Cohenの答えに似ていますが、代わりにジェネレーターです。遠く離れた色を使用することから始めます。確定的。
サンプル、左の色が最初： 
#!/usr/bin/env python3.3
import colorsys
import itertools
from fractions import Fraction
def zenos_dichotomy():
"""
http://en.wikipedia.org/wiki/1/2_%2B_1/4_%2B_1/8_%2B_1/16_%2B_%C2%B7_%C2%B7_%C2%B7
"""
for k in itertools.count():
yield Fraction(1,2**k)
def getfracs():
"""
[Fraction(0, 1), Fraction(1, 2), Fraction(1, 4), Fraction(3, 4), Fraction(1, 8), Fraction(3, 8), Fraction(5, 8), Fraction(7, 8), Fraction(1, 16), Fraction(3, 16), ...]
[0.0, 0.5, 0.25, 0.75, 0.125, 0.375, 0.625, 0.875, 0.0625, 0.1875, ...]
"""
yield 0
for k in zenos_dichotomy():
i = k.denominator # [1,2,4,8,16,...]
for j in range(1,i,2):
yield Fraction(j,i)
bias = lambda x: (math.sqrt(x/3)/Fraction(2,3)+Fraction(1,3))/Fraction(6,5) # can be used for the v in hsv to map linear values 0..1 to something that looks equidistant
def genhsv(h):
for s in [Fraction(6,10)]: # optionally use range
for v in [Fraction(8,10),Fraction(5,10)]: # could use range too
yield (h, s, v) # use bias for v here if you use range
genrgb = lambda x: colorsys.hsv_to_rgb(*x)
flatten = itertools.chain.from_iterable
gethsvs = lambda: flatten(map(genhsv,getfracs()))
getrgbs = lambda: map(genrgb, gethsvs())
def genhtml(x):
uint8Tuple = map(lambda y: int(y*255), x)
return "rgb({},{},{})".format(*uint8Tuple)
gethtmlcolors = lambda: map(genhtml, getrgbs())
if __== "__main__":
print(list(itertools.islice(gethtmlcolors(), 100)))
これがアイデアです。 HSVシリンダーを想像してください
明るさと彩度の上限と下限を定義します。これにより、空間内に正方形の断面リングが定義されます。
次に、この空間内でN個の点をランダムに散布します。
次に、一定の反復回数、または点が安定するまで、反復反発アルゴリズムを適用します。
これで、関心のある色空間内で可能な限り異なるN色を表すNポイントが得られます。
ヒューゴ
世代のために、Pythonで受け入れられている答えをここに追加します。
import numpy as np
import colorsys
def _get_colors(num_colors):
colors=[]
for i in np.arange(0., 360., 360. / num_colors):
hue = i/360.
lightness = (50 + np.random.Rand() * 10)/100.
saturation = (90 + np.random.Rand() * 10)/100.
colors.append(colorsys.hls_to_rgb(hue, lightness, saturation))
return colors
誰もが、人間の視覚システムで知覚される色の違いを表すように設計された非常に有用なYUV色空間の存在を見逃しているようです。 YUVの距離は、人間の知覚の違いを表します。 4次元ルービックキューブと、任意の数の顔を持つ無制限の数の4Dツイスティパズルを実装するMagicCube4Dにこの機能が必要でした。
私のソリューションは、YUVでランダムなポイントを選択し、次に最も近い2つのポイントを繰り返し分割し、結果を返すときにのみRGBに変換することから始まります。メソッドはO（n ^ 3）ですが、小さな数値やキャッシュ可能な数値の場合は問題になりません。確かに効率を上げることができますが、結果は素晴らしいようです。
この関数は、指定された量よりも明るいまたは暗いコンポーネントがない色を生成しないように、輝度のしきい値のオプションの指定を可能にします。 IE値を黒または白に近づけたくない場合があります。これは、結果の色が基本色として使用され、後で照明、レイヤー、透明度などによってシェーディングされ、基本色とは異なるように表示される必要がある場合に便利です。
import Java.awt.Color;
import Java.util.Random;
/**
* Contains a method to generate N visually distinct colors and helper methods.
*
* @author Melinda Green
*/
public class ColorUtils {
private ColorUtils() {} // To disallow instantiation.
private final static float
U_OFF = .436f,
V_OFF = .615f;
private static final long Rand_SEED = 0;
private static Random Rand = new Random(Rand_SEED);
/*
* Returns an array of ncolors RGB triplets such that each is as unique from the rest as possible
* and each color has at least one component greater than minComponent and one less than maxComponent.
* Use min == 1 and max == 0 to include the full RGB color range.
*
* Warning: O N^2 algorithm blows up fast for more than 100 colors.
*/
public static Color[] generateVisuallyDistinctColors(int ncolors, float minComponent, float maxComponent) {
Rand.setSeed(Rand_SEED); // So that we get consistent results for each combination of inputs
float[][] yuv = new float[ncolors][3];
// initialize array with random colors
for(int got = 0; got < ncolors;) {
System.arraycopy(randYUVinRGBRange(minComponent, maxComponent), 0, yuv[got++], 0, 3);
}
// continually break up the worst-fit color pair until we get tired of searching
for(int c = 0; c < ncolors * 1000; c++) {
float worst = 8888;
int worstID = 0;
for(int i = 1; i < yuv.length; i++) {
for(int j = 0; j < i; j++) {
float dist = sqrdist(yuv[i], yuv[j]);
if(dist < worst) {
worst = dist;
worstID = i;
}
}
}
float[] best = randYUVBetterThan(worst, minComponent, maxComponent, yuv);
if(best == null)
break;
else
yuv[worstID] = best;
}
Color[] rgbs = new Color[yuv.length];
for(int i = 0; i < yuv.length; i++) {
float[] rgb = new float[3];
yuv2rgb(yuv[i][0], yuv[i][1], yuv[i][2], rgb);
rgbs[i] = new Color(rgb[0], rgb[1], rgb[2]);
//System.out.println(rgb[i][0] + "\t" + rgb[i][1] + "\t" + rgb[i][2]);
}
return rgbs;
}
public static void hsv2rgb(float h, float s, float v, float[] rgb) {
// H is given on [0->6] or -1. S and V are given on [0->1].
// RGB are each returned on [0->1].
float m, n, f;
int i;
float[] hsv = new float[3];
hsv[0] = h;
hsv[1] = s;
hsv[2] = v;
System.out.println("H: " + h + " S: " + s + " V:" + v);
if(hsv[0] == -1) {
rgb[0] = rgb[1] = rgb[2] = hsv[2];
return;
}
i = (int) (Math.floor(hsv[0]));
f = hsv[0] - i;
if(i % 2 == 0)
f = 1 - f; // if i is even
m = hsv[2] * (1 - hsv[1]);
n = hsv[2] * (1 - hsv[1] * f);
switch(i) {
case 6:
case 0:
rgb[0] = hsv[2];
rgb[1] = n;
rgb[2] = m;
break;
case 1:
rgb[0] = n;
rgb[1] = hsv[2];
rgb[2] = m;
break;
case 2:
rgb[0] = m;
rgb[1] = hsv[2];
rgb[2] = n;
break;
case 3:
rgb[0] = m;
rgb[1] = n;
rgb[2] = hsv[2];
break;
case 4:
rgb[0] = n;
rgb[1] = m;
rgb[2] = hsv[2];
break;
case 5:
rgb[0] = hsv[2];
rgb[1] = m;
rgb[2] = n;
break;
}
}
// From http://en.wikipedia.org/wiki/YUV#Mathematical_derivations_and_formulas
public static void yuv2rgb(float y, float u, float v, float[] rgb) {
rgb[0] = 1 * y + 0 * u + 1.13983f * v;
rgb[1] = 1 * y + -.39465f * u + -.58060f * v;
rgb[2] = 1 * y + 2.03211f * u + 0 * v;
}
public static void rgb2yuv(float r, float g, float b, float[] yuv) {
yuv[0] = .299f * r + .587f * g + .114f * b;
yuv[1] = -.14713f * r + -.28886f * g + .436f * b;
yuv[2] = .615f * r + -.51499f * g + -.10001f * b;
}
private static float[] randYUVinRGBRange(float minComponent, float maxComponent) {
while(true) {
float y = Rand.nextFloat(); // * YFRAC + 1-YFRAC);
float u = Rand.nextFloat() * 2 * U_OFF - U_OFF;
float v = Rand.nextFloat() * 2 * V_OFF - V_OFF;
float[] rgb = new float[3];
yuv2rgb(y, u, v, rgb);
float r = rgb[0], g = rgb[1], b = rgb[2];
if(0 <= r && r <= 1 &&
0 <= g && g <= 1 &&
0 <= b && b <= 1 &&
(r > minComponent || g > minComponent || b > minComponent) && // don't want all dark components
(r < maxComponent || g < maxComponent || b < maxComponent)) // don't want all light components
return new float[]{y, u, v};
}
}
private static float sqrdist(float[] a, float[] b) {
float sum = 0;
for(int i = 0; i < a.length; i++) {
float diff = a[i] - b[i];
sum += diff * diff;
}
return sum;
}
private static double worstFit(Color[] colors) {
float worst = 8888;
float[] a = new float[3], b = new float[3];
for(int i = 1; i < colors.length; i++) {
colors[i].getColorComponents(a);
for(int j = 0; j < i; j++) {
colors[j].getColorComponents(b);
float dist = sqrdist(a, b);
if(dist < worst) {
worst = dist;
}
}
}
return Math.sqrt(worst);
}
private static float[] randYUVBetterThan(float bestDistSqrd, float minComponent, float maxComponent, float[][] in) {
for(int attempt = 1; attempt < 100 * in.length; attempt++) {
float[] candidate = randYUVinRGBRange(minComponent, maxComponent);
boolean good = true;
for(int i = 0; i < in.length; i++)
if(sqrdist(candidate, in[i]) < bestDistSqrd)
good = false;
if(good)
return candidate;
}
return null; // after a bunch of passes, couldn't find a candidate that beat the best.
}
/**
* Simple example program.
*/
public static void main(String[] args) {
final int ncolors = 10;
Color[] colors = generateVisuallyDistinctColors(ncolors, .8f, .3f);
for(int i = 0; i < colors.length; i++) {
System.out.println(colors[i].toString());
}
System.out.println("Worst fit color = " + worstFit(colors));
}
}
完全に誇張されている「個別の」問題を管理するためのソリューションを次に示します。
単位球体を作成し、反発する電荷で点をドロップします。パーティクルシステムが移動しなくなるまで（またはデルタが「十分に小さい」まで）実行します。この時点で、各ポイントは互いに可能な限り離れています。 （x、y、z）をrgbに変換します。
特定のクラスの問題については、このタイプのソリューションはブルートフォースよりもうまく機能するためです。
私はもともと ここでのアプローチ をテッセレーションするために見ました。
繰り返しますが、HSL空間またはRGB空間をトラバースする最も明白なソリューションは、おそらくうまく機能します。
HSLカラーモデルは「ソート」カラーに適していますが、視覚的に異なるカラーを探している場合は、代わりに Lab カラーモデルが必要です。
CIELABは、人間の色覚に関して知覚的に均一になるように設計されています。つまり、これらの値の同じ量の数値変化は、視覚的に知覚される変化のほぼ同じ量に対応します。
それがわかったら、広範囲の色からN色の最適なサブセットを見つけることは依然として（NP）難しい問題であり、 Travelling salesman problem とk-meanを使用するすべてのソリューションに似ていますアルゴリズムまたは何かが本当に助けにはなりません。
つまり、Nが大きすぎず、限られた色のセットから開始する場合、単純なランダム関数を使用して、Lab距離に従って非常に優れた個別の色のサブセットを簡単に見つけることができます。
私は自分の使用のためにそのようなツールをコーディングしました（ここで見つけることができます： https://mokole.com/palette.html ）、ここに私がN = 7で得たものがあります：- 
すべてjavascriptなので、ページのソースを自由に見て、自分のニーズに合わせて調整してください。
彩度と輝度を最大に修正し、色相のみに焦点を当てようとします。私が見るように、Hは0から255になり、ラップアラウンドします。 2つの対照的な色が必要な場合は、このリングの反対側、つまり0と128を使用します。4色が必要な場合は、円の256の長さの1/4、つまり0、64、128、192で分離します。そしてもちろん、N色が必要なときに他の人が提案したように、256/Nでそれらを分けることができます。
このアイデアに追加するのは、2進数の逆表現を使用してこのシーケンスを形成することです。これを見てください：
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の累乗である）同時に、シーケンスは大きく異なります。
これは私の使用例で重要な目標でした。なぜなら、色がこの色で覆われた領域でソートされたチャートがあったからです。チャートの最大の領域に大きなコントラストを持たせたいと思っていましたが、一部の小さな領域ではトップ10の色に似た色にすることは問題ありませんでした。
この単純な再帰アルゴリズムは、明確な色相値を生成するために、受け入れられた答えを補完すると思います。 hsv用に作成しましたが、他の色空間にも使用できます。
サイクルごとに色相を生成し、各サイクルで互いに可能な限り分離します。
/**
* 1st cycle: 0, 120, 240
* 2nd cycle (+60): 60, 180, 300
* 3th cycle (+30): 30, 150, 270, 90, 210, 330
* 4th cycle (+15): 15, 135, 255, 75, 195, 315, 45, 165, 285, 105, 225, 345
*/
public static float recursiveHue(int n) {
// if 3: alternates red, green, blue variations
float firstCycle = 3;
// First cycle
if (n < firstCycle) {
return n * 360f / firstCycle;
}
// Each cycle has as much values as all previous cycles summed (powers of 2)
else {
// floor of log base 2
int numCycles = (int)Math.floor(Math.log(n / firstCycle) / Math.log(2));
// divDown stores the larger power of 2 that is still lower than n
int divDown = (int)(firstCycle * Math.pow(2, numCycles));
// same hues than previous cycle, but summing an offset (half than previous cycle)
return recursiveHue(n % divDown) + 180f / divDown;
}
}
ここでこの種のアルゴリズムを見つけることができませんでした。これがお役に立てば幸いです。最初の投稿です。
この目的のために特別に設計された qualpalr というR用のパッケージを作成しました。 vignette を見て、どのように機能するかを調べることをお勧めしますが、主なポイントを要約してみます。
qualpalrは HSL色空間 （このスレッドで前述した）で色の指定を取得し、DIN99d色空間（知覚的に均一）に投影し、nを見つけるOIF間の最小距離を最大化します。
# Create a palette of 4 colors of hues from 0 to 360, saturations between
# 0.1 and 0.5, and lightness from 0.6 to 0.85
pal <- qualpal(n = 4, list(h = c(0, 360), s = c(0.1, 0.5), l = c(0.6, 0.85)))
# Look at the colors in hex format
pal$hex
#> [1] "#6F75CE" "#CC6B76" "#CAC16A" "#76D0D0"
# Create a palette using one of the predefined color subspaces
pal2 <- qualpal(n = 4, colorspace = "pretty")
# Distance matrix of the DIN99d color differences
pal2$de_DIN99d
#> #69A3CC #6ECC6E #CA6BC4
#> 6ECC6E 22
#> CA6BC4 21 30
#> CD976B 24 21 21
plot(pal2)
Nが十分に大きい場合、似たような色が得られます。世界にはそんなにたくさんありません。
次のように、スペクトル全体で均等に分散しないのはなぜですか。
IEnumerable<Color> CreateUniqueColors(int nColors)
{
int subdivision = (int)Math.Floor(Math.Pow(nColors, 1/3d));
for(int r = 0; r < 255; r += subdivision)
for(int g = 0; g < 255; g += subdivision)
for(int b = 0; b < 255; b += subdivision)
yield return Color.FromArgb(r, g, b);
}
同じ色が互いに隣り合わないようにシーケンスを混ぜたい場合は、結果のリストをシャッフルすることができます。
私はこれを考えていますか？
これは、MATLABでは簡単です（hsvコマンドがあります）。
cmap = hsv(number_of_colors)