Comment générer automatiquement N couleurs "distinctes"?
J'ai écrit les deux méthodes ci-dessous pour sélectionner automatiquement N couleurs distinctes. Cela fonctionne en définissant une fonction linéaire par morceaux sur le cube RGB. L'avantage de ceci est que vous pouvez également obtenir une échelle progressive si c'est ce que vous voulez, mais lorsque N devient grand, les couleurs peuvent commencer à se ressembler. Je peux également imaginer de sous-diviser le cube RVB en un réseau, puis de dessiner des points. Est-ce que quelqu'un connaît d'autres méthodes? J'exclus de définir une liste et ensuite de la parcourir. Je devrais aussi dire que je ne me soucie généralement pas de savoir si elles se heurtent ou si elles ne semblent pas agréables, elles doivent simplement être visuellement distinctes.
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);
}
Vous pouvez utiliser le modèle de couleur HSL pour créer vos couleurs.
Si tout ce que vous voulez, ce sont des teintes différentes (probablement) et de légères variations de luminosité ou de saturation, vous pouvez les répartir de la manière suivante:
// 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);
}
Cette question apparaît dans pas mal de SO discussions:
- algorithme pour générer des couleurs uniques
- Générer des couleurs uniques
- Générer des couleurs RVB distinctement différentes dans les graphiques
- Comment générer n couleurs différentes pour n’importe quel nombre naturel n?
Différentes solutions sont proposées, mais aucune n’est optimale. Heureusement, science vient à la rescousse
N arbitraire
- écrans couleur pour les images catégoriques (téléchargement gratuit)
- N SERVICE WEB POUR PERSONNALISER LA COLORATION DES CARTES (téléchargement gratuit, une solution de service Web devrait être disponible le mois prochain)
- n algorithme pour la sélection de jeux de couleurs à contraste élevé (les auteurs proposent une implémentation gratuite de C++)
- jeux de couleurs à contraste élevé (premier algorithme du problème)
Les 2 derniers seront gratuits via la plupart des bibliothèques/procurations universitaires.
N est fini et relativement petit
Dans ce cas, on pourrait opter pour une solution de liste. Un article très intéressant sur le sujet est disponible gratuitement:
Il y a plusieurs listes de couleurs à considérer:
- La liste de Boynton de 11 couleurs qui ne sont presque jamais confondues (disponible dans le premier article de la section précédente)
- Les 22 couleurs de contraste maximum de Kelly (disponible dans le document ci-dessus)
J'ai aussi rencontré this Palette par un étudiant MIT). Enfin, les liens suivants peuvent être utiles pour la conversion entre différents systèmes de couleur/coordonnées (certaines couleurs dans les articles sont: non spécifié en RVB, par exemple):
- http://chem8.org/uch/space-55036-do-blog-id-5333.html
- https://metacpan.org/pod/Color::Library::Dictionary::NBS_ISCC
- Théorie des couleurs: Comment convertir Munsell HVC en RGB/HSB/HSL
Pour la liste de Kelly et Boynton, j'ai déjà effectué la conversion au format RVB (à l'exception du blanc et du noir, ce qui devrait être évident). Un code 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);
}
Et voici les valeurs RVB en représentations hexadécimales et 8 bits par canal:
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))
Pour tous les développeurs Java, voici les couleurs 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
};
vous trouverez ci-dessous les couleurs Kelly triées selon l'ordre ci-dessus.
voici les couleurs kelly triées en fonction des teintes (à noter que certains jaunes ne sont pas très contrastés)
Comme la réponse d'Uri Cohen, mais est un générateur à la place. Commençons par utiliser des couleurs très éloignées. Déterministe.
Échantillon, couleurs de gauche en premier: 
#!/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)))
Voici une idée. Imaginez un cylindre HSV
Définissez les limites supérieure et inférieure souhaitées pour la luminosité et la saturation. Ceci définit un anneau de section carrée dans l'espace.
Maintenant, dispersez N points au hasard dans cet espace.
Appliquez ensuite un algorithme de répulsion itérative sur eux, soit pour un nombre fixe d’itérations, soit jusqu’à stabilisation des points.
Vous devez maintenant avoir N points représentant N couleurs qui sont aussi différentes que possible de l’espace colorimétrique qui vous intéresse.
Hugo
Pour les générations à venir, j'ajoute ici la réponse acceptée en 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
Tout le monde semble avoir oublié l'existence de l'espace colorimétrique YUV très utile, conçu pour représenter les différences de couleur perçues dans le système visuel humain. Les distances en YUV représentent les différences de perception humaine. J'avais besoin de cette fonctionnalité pour MagicCube4D qui implémente des cubes de Rubik à 4 dimensions et un nombre illimité d'autres énigmes tordues 4D ayant un nombre de faces arbitraire.
Ma solution commence en sélectionnant des points aléatoires dans YUV, puis en divisant de manière itérative les deux points les plus proches et en ne convertissant en RVB que lorsque le résultat est renvoyé. La méthode est O (n ^ 3), mais cela n'a pas d'importance pour les petits nombres ou ceux qui peuvent être mis en cache. Cela peut certainement être rendu plus efficace, mais les résultats semblent excellents.
La fonction permet de spécifier en option des seuils de luminosité afin de ne pas produire de couleurs dans lesquelles aucun composant n’est plus brillant ou plus foncé que les valeurs données. IE vous ne voudrez peut-être pas de valeurs proches du noir ou du blanc. Cela est utile lorsque les couleurs résultantes seront utilisées comme couleurs de base qui seront ensuite ombrées via l'éclairage, la superposition, la transparence, etc. semblent différentes de leurs couleurs de base.
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));
}
}
Voici une solution pour gérer votre problème "distinct", qui est totalement exagéré:
Créez une unité de sphère et déposez des points dessus avec des charges repoussantes. Exécutez un système de particules jusqu'à ce qu'ils ne bougent plus (ou que le delta soit "suffisamment petit"). À ce stade, chacun des points est aussi éloigné que possible l'un de l'autre. Convertir (x, y, z) en RGB.
Je le mentionne car, pour certaines catégories de problèmes, ce type de solution peut fonctionner mieux que la force brute.
J'ai initialement vu cette approche ici pour tesseler une sphère.
Là encore, les solutions les plus évidentes consistant à traverser un espace HSL ou un espace RVB fonctionneront probablement très bien.
Le modèle de couleur HSL peut être bien adapté au "tri" des couleurs, mais si vous recherchez des couleurs visuellement distinctes, vous avez définitivement besoin du modèle de couleur Laboratoire .
CIELAB a été conçu pour être perceptuellement uniforme en ce qui concerne la vision des couleurs humaine, ce qui signifie que la même quantité de changement numérique dans ces valeurs correspond à peu près au même nombre de changement perçu visuellement.
Une fois que vous savez cela, trouver le sous-ensemble optimal de N couleurs parmi une large gamme de couleurs reste un problème difficile (NP), un peu similaire au problème du voyageur de commerce et à toutes les solutions utilisant k-mean algorithmes ou quelque chose ne va pas vraiment aider.
Cela dit, si N n’est pas trop grand et si vous commencez avec un jeu de couleurs limité, vous trouverez facilement un très bon sous-ensemble de couleurs distinctes en fonction d’une distance Lab avec une fonction aléatoire simple.
J'ai codé un tel outil pour mon usage personnel (vous pouvez le trouver ici: https://mokole.com/palette.html ), voici ce que j'ai pour N = 7: - 
Tout est en javascript, alors n'hésitez pas à consulter la source de la page et à l'adapter à vos besoins.
J'essayerais de régler la saturation et la lumination au maximum et de me concentrer uniquement sur la teinte. Comme je le vois, H peut aller de 0 à 255, puis tourne autour. Maintenant, si vous vouliez deux couleurs contrastantes, vous prendriez les côtés opposés de cet anneau, à savoir 0 et 128. Si vous vouliez quatre couleurs, vous en sépareriez par 1/4 de la longueur totale du cercle, soit 0, 64,128,192. Et bien sûr, comme d'autres l'ont suggéré lorsque vous avez besoin de N couleurs, vous pouvez simplement les séparer par 256/N.
Ce que j’ajouterais à cette idée est d’utiliser une représentation inversée d’un nombre binaire pour former cette séquence. Regarde ça:
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
... de cette façon, si vous avez besoin de N couleurs différentes, vous pouvez simplement prendre les N premiers chiffres, les inverser et vous obtenez autant de points distants que possible (N étant la puissance de deux) tout en conservant chaque préfixe du la séquence diffère beaucoup.
C’était un objectif important dans mon cas d’utilisation, car j’avais un tableau dans lequel les couleurs étaient triées par zones couvertes par cette couleur. Je voulais que les zones les plus larges du graphique aient un contraste élevé, et je suis d'accord avec certaines zones qui ont des couleurs similaires à celles du top 10, car il était évident pour le lecteur de savoir laquelle est celle en observant simplement la zone.
Je pense que cet algorithme récursif simple complète la réponse acceptée, afin de générer des valeurs de teinte distinctes. Je l'ai fait pour le hsv, mais je peux aussi l'utiliser pour d'autres espaces colorimétriques.
Il génère des teintes par cycles, aussi séparés que possible les uns des autres à chaque cycle.
/**
* 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;
}
}
Je n'ai pas pu trouver ce genre d'algorithme ici. J'espère que cela aide, c'est mon premier post ici.
J'ai écrit un paquetage pour R appelé qualpalr spécialement conçu à cet effet. Je vous recommande de regarder vignette pour savoir comment cela fonctionne, mais je vais essayer de résumer les points principaux.
qualpalr prend une spécification de couleurs dans le espace colorimétrique HSL (décrit précédemment dans ce fil), le projette dans l'espace colorimétrique DIN99d (uniformément perceptible) et trouve le n qui maximise la distance minimale entre tous les objets.
# 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)
Si N est assez grand, vous obtiendrez des couleurs similaires. Il n'y en a pas beaucoup dans le monde.
Pourquoi ne pas simplement les distribuer uniformément à travers le spectre, comme suit:
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);
}
Si vous souhaitez mélanger la séquence de manière à ce que des couleurs similaires ne soient pas côte à côte, vous pouvez peut-être mélanger la liste résultante.
Suis-je en train de penser cela?
Ceci est trivial dans MATLAB (il y a une commande hsv):
cmap = hsv(number_of_colors)