Discussion :

[Simon MARQUIS]

Bonjour à tous,

J'ai actuellement écrit un code pour réaliser un dégradé de couleur entre deux couleur.
La fonction me retourne une liste de couleurs (triées)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
		int r=(Color.red(MainActivity.f_color) - Color.red(MainActivity.e_color))/(((nb_etats == 2 ? 1 : nb_etats)-2));
		int g=(Color.green(MainActivity.f_color) - Color.green(MainActivity.e_color))/(((nb_etats == 2 ? 1 : nb_etats)-2));
		int b=(Color.blue(MainActivity.f_color) - Color.blue(MainActivity.e_color))/(((nb_etats == 2 ? 1 : nb_etats)-2));
 
		MainActivity.paintList = new ArrayList<Paint>();
 
		for(int i=0;i<nb_etats;i++){
			Paint p= new Paint();
			p.setColor(Color.rgb(Color.red(MainActivity.f_color)-i*r, Color.green(MainActivity.f_color)-i*g, Color.blue(MainActivity.f_color)-i*b));
			MainActivity.paintList.add(p);
		}

Cepandant, je n'arriver pas à adapter mon code pour qu'il puisse prendre en compte trois (voire x) couleurs.

Pourriez vous m'aider s'il-vous plait ?
Merci d'avance

[Mopmop]

Malheureusement en utilisant ta méthode, tu ne peux pas généraliser...

C'est des math plus que de l'algorithme la...

Pour 2 couleurs tu as posé l'équation
C = a.i + b (a et b inconnus et C la couleur)

Ensuite t'as posé
pour i=0 ==> C = f_color
pour i = nb_etats ==> C = e_color

T'as donc le système d'équations :
f_color = b
a.nb_etats + b = e_color

ce qui donne facilement (pour i allant de 0 à nb_etats)
C = f_color - (f_color - e_color)*i/nb_etats ;

==> Et c'est exactement ce que fait ton algo <==

Ben pour trois couleurs le principe est le même, sauf que comme il y a une couleur de plus, il faut ajouter un degré à ton équation et donc poser
C = a.i² + b.i + c

Et les conditions sont :
pour i = 0 ==> C = couleur1 (c1)
pour i = nb_etats/2 ==> C = couleur2 (c2)
pour i = nb_etats ==> C = couleur3 (c3)


Je vais pas détailler la résolution et ça donne, avec nb_etats = N (attention ça pique ) :
C = (2.c3 - 4.c2 + 2.c1).i/N² + (4.c2 - 3.c1 - c3)*i/N + c1


Ensuite tu l'auras compris, pour x couleurs, ça pique de plus en plus...
T'as donc le choix :

• Soit tu fais les calculs à la main pour le nombre de couleurs que tu veux... s'il est élevé t'en as pour un moment.
• Soit tu trouves une API qui résout les systèmes d'équations... ça doit bien exister.
• Soit tu trouves une API qui fait les dégradés... idem, ça doit bien exister.
• Soit tu changes ton algo et t'en trouves un sans math (je sais pas si c'est possible... j'y ai pas réfléchi mais j'ai un gros doute la dessus )
• Soit tout simplement tu te contentes de 2 (ou même 3 maintenant) couleurs.

Voila, j'espère que j'ai été assez clair et que j'ai fait peur à personne avec mes math

[le y@m's]

Est-ce volontaire que tu veuilles volontairement recréer un algo pour effectuer un dégradé de couleur et ne pas utiliser les MultipleGradientPaint (LinearGradientPaint et RadialGradientPaint) de l'API standard ?

[Simon MARQUIS]

Déjà, merci beaucoup pour vos réponses.
@ le yams : En fait, je souhaite effectuer cela pour une application android. C'est à dire que, pour chaque valeur de nb_etats je veux créer un objet Paint qui aurait la valeur d'une couleur. La liste de ces Paints devra être dégradé. Les LinearGradiant etc ne sont donc pas adaptés ici (plutôt utilisés pour réaliser une interface ou ce genre de choses)
@ Mopmop : J'y avait pas pensé (pourtant je suis en école d'ingé, mais les maths et moi ...). Il est vrai que pour deux couleurs c'est "trivial", pour trois un peu moins, et ça va de pire en pire. Je pense que je vais me limiter à trois couleurs.
Pour évider trop de calculs de résolution d'équations, j'ai réalisé les calculs en créant le dégradé de la 1ere couleur à la 2eme , puis de la 2eme à la 3eme, en séparant les deux calculs. Et ça a l'air de fonctionner.

Merci beaucoup pour votre aide.

[Mopmop]

Pour évider trop de calculs de résolution d'équations, j'ai réalisé les calculs en créant le dégradé de la 1ere couleur à la 2eme , puis de la 2eme à la 3eme, en séparant les deux calculs. Et ça a l'air de fonctionner.

J'avais pas pensé à ça tient... du coup ça te donne la solution pour x couleurs !

Quelque chose dans ce genre :

Code :

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
25
26
27
28
29
30
31
32
 
 
private ArrayList<Paint> degrader2Couleurs(Color couleur1, Color couleur2, int nb_etats)
{
		int r=(Color.red(couleur1) - Color.red(couleur2))/(((nb_etats == 2 ? 1 : nb_etats)-2));
		int g=(Color.green(couleur1) - Color.green(couleur2))/(((nb_etats == 2 ? 1 : nb_etats)-2));
		int b=(Color.blue(couleur1) - Color.blue(couleur2))/(((nb_etats == 2 ? 1 : nb_etats)-2));
 
		ArrayList<Paint> aRenvoyer = new ArrayList<Paint>();
 
		for(int i=0;i<nb_etats;i++){
			Paint p= new Paint();
			p.setColor(Color.rgb(Color.red(couleur1)-i*r, Color.green(couleur1)-i*g, Color.blue(couleur1)-i*b));
			aRenvoyer.add(p);
		}
     return aRenvoyer ;
}
 
public void degraderXCouleurs(ArrayList<Color> lesCouleurs, nb_etats)
{
   MainActivity.paintList = new ArrayList<Paint>(); 
   int nb_etats_intermediaires = nb_etats / (lesCouleurs.size() - 1) ;
 
   int i = 0 ;  
   while ( i<lesCouleurs.size() - 1)
   {
     paintList .add(degrader2Couleurs(lesCouleurs.get(i), lesCouleurs.get(i+1), nb_etats_intermediaires) ;
     i++ ;
   }
 
 
}

Donc tu te fais une liste de couleurs (dans l'ordre dans lequel tu veux voir le dégradé) et t'envois ça à degraderXCouleurs avec le nombre d'états voulu.... et à priori ça devrait marcher niquel (faut juste pas oublier les cas particulier pas bien méchants comme nb_etats = 1 et lesCouleurs.size() = 0/1).


Donc j'avais un doute tout a l'heure, mais finalement il y avait bien une solution sans math .

Wouala wouala !