Discussion :

[Invité]

Salut à tous !

Voilà, j'espère être dans le bon forum, parce que c'est bien un algo que je cherche... Je voudrais générer une suite de n couleurs, automatiquement et de manière à obtenir des couleurs assez différentes, surtout celles qui se suivent dans la suite.

En fait, je veux me servir de cette "palette" pour générer des graphiques ; par exemple un graphique camembert (pas sure de l'orthographe ) dans lequel il faut absolument que les couleurs contiguës soient très différentes et de manière générale que les couleurs soient au maximum différentes pour pouvoir les identifier à partir de la légende.

J'ai essayé de trouver des algos sur google, mais c'est pas évident et ça ne donne souvent pas des couleurs assez différentes (différentiable à l'œil) :-/

Merci d'avance pour vos idées

[ToTo13]

Bonjour,

juste quelques précisions. Les différencier à l'œil nu ne veut absolument pas dire éloigné dans la palette de couleur surtout en fonction de l'espace dans lequel tu travailles.
Pour cette raison, il me semble que l'espace HLS est le plus adapté à ton problème, mais pas le RGB.
Ensuite, les espaces sont en trois dimensions, donc on ne peut pas les diviser très facilement. Tu peux essayer de diviser l'espace HLS en N espaces de même volume, mais je ne suis pas sûr de la qualité du résultat. Sinon tu peux essayer de faire un petit K-Means avec un nombre de classe égal au nombre de couleurs que tu souhaites. De manière plus générale, toute méthode de classification (clustering en anglais) marchera pour te diviser ton espace.

[Invité]

Merci pour ta réponse rapide !

Juste quelques petites précisions de termes que je n'ai pas compris si c'est possible
- espace HLS
- K-Means

[ToTo13]

Bonjour,

HLS => Il existe différents espace de représentation de la couleur (RBG, RGBA, HLS, Lav, YUV, ...). Ces différents mode de représentation de la couleur sont plus ou moins pratique pour travailler et offrent chacun avantages et inconvénients. L'industrie adore le Lab, mais celui qui semble être souvent le plus pratique est le HLS (représentation de l'espace de couleur en cône).

K-Means => En français K-moyennes, c'est une méthode de classification (vient de l'anglais clustering). Elle permet de regrouper des individus dans un nombre de classe prédéfini. Dans ton cas, les individus sont toutes les couleurs (ou combinaison de couleur) possibles et le nombre de classe est le nombre de couleur que tu souhaites mettre dans ta palette. Donc cette méthode divisera ton espace de travail en un certain nombre de partition (classe) et le barycentre de chaque partition est la couleur que tu souhaites mettre dans ta palette. J'ai posté une version Java des K-Means dans la rubrique contribuez.

[ArgusAzure]

Je pense que tu cherches des couleurs qui soient vives (saturées) et pas des couleurs un peu fades.
Donc je te conseille de travailler en HLS avec la luminance L moyenne et la saturation S au maximum.
Ensuite, tu génères tes différentes valeurs de hue H. En général, c'est exprimé sur 360°. C'est quand même plus simple s'il n'y a qu'une dimension
Donc ton problème se résume à trouver une suite de nombres de [0..360[ qui soient assez éloignés consécutivement.
Par exemple
0 30 60 90 ....330 15 45 75 ... 345 7 37 ...

Tu peux convertir chacune des couleurs générées en RGB si tu préfères cette représentation.

[Invité]

Comme je le disais avant le crash de la base, merci à vous deux

Pour le moment, je suis partie sur une solution "en dur" par manque de temps, mais j'y reviendrai certainement

@ArgusAzure: ça me paraît intéressant, je me pencherai sur cette solution, mais comment puis-je faire (de manière assez simple) pour passer du mode HLS au mode RVB ? (je n'ai trouvé que des calculs très long, ce qui ne m'arrange pas trop...) Existe-t-il une méthode qui donne une conversion simple ? (même approchée)

[pseudocode]

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
// input  H,S,B in [0,1]
// output RGB in [0,0xFFF]
int hsv2rgb(float H, float S,float V) {
	float Hf=(H-(int)H)*6;
	int Hi= (int)Hf;
 
	float f = Hf-Hi;
	float p = V*(1-S);
	float q = V*(1-f*S);
	float t = V*(1-(1-f)*S);
 
	int R=0,G=0,B=0;
	switch(Hi) {
	case 0: R=(int)(V*255); G=(int)(t*255);  B=(int)(p*255); break;
	case 1: R=(int)(q*255); G=(int)(V*255);  B=(int)(p*255); break;
	case 2: R=(int)(p*255); G=(int)(V*255);  B=(int)(t*255); break;
	case 3: R=(int)(p*255); G=(int)(q*255);  B=(int)(V*255); break;
	case 4: R=(int)(t*255); G=(int)(p*255);  B=(int)(V*255); break;
	case 5: R=(int)(V*255); G=(int)(p*255);  B=(int)(q*255); break;
	}
 
	return (R<<16)|(G<<8)|B;
}

[lguignar]

bonjour, je profite de ce post pour formuler une question un peu du même genre.

Je cherche à faire une palette de couleurs, mais par contre elles doivent se suivre. Pour faire une sorte de dégradé (c'est aussi pour des graphiques)
pour l'instant ça donne ceci :


Je connais le min et le max des valeurs.
Pour chaque valeur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
si val/(max*0.8)=0 alors noir
sinon si val/(max*0.8)=1 alors blanc
sinon (0, val/(max*0.8), 0)

(R, G, B) la plage va de 0 à 1

Y a t il une manière plus élégante (sans les "si-sinon") qui rende plus "smoothy" l'image?

Merci d'avance, Léo

[pseudocode]

Y a t il une manière plus élégante (sans les "si-sinon") qui rende plus "smoothy" l'image?

L'espace de couleur HLS marche bien dans ce cas.

H = constante (= 120° pour du vert)
S = constante (100%)
L = variable (entre 0 et 100%)

[lguignar]

oui c'est pas mal, ça rend plutôt bien.
Mais en fait j'aimerai, si possible, aller jusqu'au blanc, voir même jusqu'au jaune (pour avoir une sensation de "brillance") du genre ça :

c'était les images initiales, malheureusement je n'ai pas le source de création de celles-ci.

[pseudocode]

Mais en fait j'aimerai, si possible, aller jusqu'au blanc, voir même jusqu'au jaune (pour avoir une sensation de "brillance")

Pour L=100%, le HSL va jusqu'au blanc (a la difference du HSV).
Pour modifier egalement la teinte, il faut faire varier la valeur de H.

pour 0.0<val<1.0

• hue=(1-val)*120° + val*60°
• sat=100%
• lum=val*100%