Discussion :

[Peviden]

Bonjour,

J'expose mon problème: J'ai créé une fonction en C qui rempli une matrice de valeurs(40 000 valeurs). A l'aide de la bibliothèque SDL, j'aimerais afficher un code couleur correspondant à chacune des valeurs de la matrice. Je suis arrivé à quelque chose mais d'assez médiocre. En effet, cela est censé ressembler à un champ de pression, il faut donc par exemple pour une pression élevée un rouge vif qui régresse en passant par le jaune,vert et finissant par le bleu pour une faible pression, tout ça en dégradé.
Jusqu'à présent tout ce que je parviens à faire, c'est passer d'un rouge très foncé à un rouge de plus en plus clair jusqu'au blanc.

Je me demandais donc s'il existait une fonction toute faite dans laquelle j'entrerais la valeur de ma matrice et qui me renverrais 3 valeurs qui correspondrait à un code couleur RVB. Valeurs que je pourrais ensuite envoyer à la fonction SDL_FillRect. Ou encore si vous connaissiez un autre moyen de parvenir à ce résultat

J’espère avoir été clair dans mon explication.

D'avance merci,
Peviden

[gerald3d]

Ca ressemble à de l'interpolation linéaire ce que tu cherches à faire.

Tu as une échelle de variation : 0 --> 1000 par exemple.
Tu part d'une couleur vers une autre : rouge --> vert par exemple.

Tu trouveras sur Wikipedia les formules de bases pour mettre en application ta conversion de couleur.

[Peviden]

Bonjour,

Justement, ce n'est pas l'interpolation linéaire qui me pose problème. Jusqu'à présent j'ai ramené cette variation de mille aux 256 couleurs de rouges(ce qui donne un résultat assez médiocre). Ce que j'aimerais c'est une plage de variation de couleur beaucoup plus grande que 256 mais qui garde un dégradé logique ( rouge-->jaune-->vert-->bleu).

[kwariz]

Salut,

tu interpoles plusieurs fois de suite :

Code :

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

1
2
3
4
5
6
7
8
 
 
    0         333       666      1000
    Rouge --> Jaune --> Vert --> Bleu
 
R   255       0         0        0
G   0         255       255      0
B   0         255       0        255

[gerald3d]

Ne sachant que faire je me suis amusé à écrire un petit programme pour tenter d'obtenir ce que tu recherches. tu trouveras en pièce jointe une copie d'écran qui représente un arc-en-ciel basé sur 4 couleurs :

• noire
• bleue
• verte
• jaune
• rouge

L'intervalle de passage d'une couleur à l'autre est 250 soit au totale une échelle sur 1000.

Pour faire court voila un code exemple qui va te permettre de récupérer une composante RVB. Tu transmets à la fonction l'intervalle sur lequel tu veux travailler, la position actuelle dans l'intervalle, la couleur de départ et la couleur d'arrivée. Tu récupères dans ResultColor la couleur correspondante :

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
typedef struct
{
  guchar red;
  guchar green;
  guchar blue;
} RGB;
 
void
interpolation (int intervalle, int index, RGB *StartColor, RGB *EndColor, RGB *ResultColor)
{
  if (!ResultColor) return;
 
  ResultColor->red = (((double)index/intervalle)*EndColor->red) + ((double)(intervalle-index)/intervalle)*StartColor->red;
  ResultColor->green = (((double)index/intervalle)*EndColor->green) + ((double)(intervalle-index)/intervalle)*StartColor->green;
  ResultColor->blue = (((double)index/intervalle)*EndColor->blue) + ((double)(intervalle-index)/intervalle)*StartColor->blue;
}

[gerald3d]

Finalement, avant que j'efface ce petit programme test je le poste en entier ici. Dés fois que ca en intéresse quelques uns . Il utilise les bibliothèques Gtk+.

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#include <gtk/gtk.h>
 
typedef struct
{
  guchar red;
  guchar green;
  guchar blue;
} RGB;
 
void
interpolation (int intervalle, int index, RGB *StartColor, RGB *EndColor, RGB *ResultColor)
{
  if (!ResultColor) return;
 
  ResultColor->red = (((double)index/intervalle)*EndColor->red) + ((double)(intervalle-index)/intervalle)*StartColor->red;
  ResultColor->green = (((double)index/intervalle)*EndColor->green) + ((double)(intervalle-index)/intervalle)*StartColor->green;
  ResultColor->blue = (((double)index/intervalle)*EndColor->blue) + ((double)(intervalle-index)/intervalle)*StartColor->blue;
}
 
int
main(int argc, char *argv[])
{
  RGB Red, Green, Yellow, Blue, Black;
  RGB ResultColor;
  int i=0, j=0;
  GtkWidget *Window = NULL;
  GtkWidget *Image = NULL;
  GdkPixbuf *Pixbuf = NULL;
  guchar *Pixels = NULL;
 
  gtk_init (&argc, &argv);
 
  /* Définition de la couleur noire */
  Black.red = 0;
  Black.green = 0;
  Black.blue = 0;
 
  /* Définition de la couleur rouge */
  Red.red = 255;
  Red.green = 0;
  Red.blue = 0;
 
  /* Définition de la couleur jaune */
  Yellow.red = 255;
  Yellow.green = 255;
  Yellow.blue = 0;
 
  /* Définition de la couleur verte */
  Green.red = 0;
  Green.green = 255;
  Green.blue = 0;
 
  /* Définition de la couleur bleue */
  Blue.red = 0;
  Blue.green = 0;
  Blue.blue = 255;
 
  /* Création d'une fenêtre Gtk */
  Window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (Window), "Arc-en-ciel");
  g_signal_connect (G_OBJECT (Window), "delete-event", gtk_main_quit, NULL);
 
  /* Création d'une image pixbuf représentant un arc-en-ciel sur une échelle de 0 à 1000*/
  Pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, 1000, 200);
  Pixels = gdk_pixbuf_get_pixels (Pixbuf);
 
  for (i=0; i<1000; i++)
    {
      if (i<250) interpolation (250, i, &Black, &Blue, &ResultColor);
      else
      	if (i<500 && i>=250) interpolation (250, i-250, &Blue, &Green, &ResultColor);
      	else
      	  if (i<750 && i>=500) interpolation (250, i-500, &Green, &Yellow, &ResultColor);
      	  else
      	    interpolation (250, i-750, &Yellow, &Red, &ResultColor);
 
      for (j=0; j<200; j++)
	{
	  Pixels[(i*gdk_pixbuf_get_n_channels (Pixbuf)) + (j*gdk_pixbuf_get_rowstride (Pixbuf))] = ResultColor.red;
	  Pixels[(i*gdk_pixbuf_get_n_channels (Pixbuf)) + (j*gdk_pixbuf_get_rowstride (Pixbuf))+1] = ResultColor.green;
	  Pixels[(i*gdk_pixbuf_get_n_channels (Pixbuf)) + (j*gdk_pixbuf_get_rowstride (Pixbuf))+2] = ResultColor.blue;
	}
    }
 
  /* Conversion et affichage de l'arc-en-ciel */
  Image = gtk_image_new_from_pixbuf (Pixbuf);
  g_object_unref (Pixbuf);
  gtk_container_add (GTK_CONTAINER(Window), Image);
 
  gtk_widget_show_all(Window);
 
  gtk_main ();
 
  return 0;
}

[denispir]

Jusqu'à présent tout ce que je parviens à faire, c'est passer d'un rouge très foncé à un rouge de plus en plus clair jusqu'au blanc.
n

il me semble que peut-être tu te compliques la vie en n'utilisant pas le "espace de couleurs" approprié. Ce n'est pas en RGB que tu peux faire cela facilement (si c'est en RGB que tu codes), mais en HSL: là, tu disposes des composantes hue (teinte), saturation, lightness (luminosité). Faire ton dégradé de teinte correspond alors à interpoler sur la composante H, uniquement. En plus, tu peux alors jouer aussi sur les autres composantes, si utile (ou joli ;-).
J'imagine que tu trouveras facilement des fonctions de conversion RGB-->HSL et retour.

Denis

PS: évite le codage HSV qui est complètement contre-intuitif (à mon avis).

[Peviden]

Bonjour,

Merci pour vos réponses!
J'ai finalement fais une fonction qui vas dans le sens de gerald3d(en effet j'ai capté la logique du code de couleur RGB plus tard en jouant avec paint ce qui m'a permit de coder et c'est encore après que j'ai vu ta réponse ) , cependant celle que j'ai faite fonctionne mais me semble bien moins efficace :p
Je garde donc vos réponses en vue d'une améliorations future.