Discussion :

[skip78]

Salut à tous !

Bon alors j'aimerais faire de simples manipulations de pixels dans mon apli GTK+.
A priori rien de bien compliqué, puisqu'il existe les GdkPixbuf.
En effet je me disais que vu leur nom, ils me permettraient de récupérer un buffer de pixel ?

Bah j'ai beau parcourir la toile, personne est capable de m'expliquer comment on fait ^^

Il existe bien une fonction gdk_get_pixel, mais qui renvoie un guchar*, qui semble se manier de bien étrange facon pour récupérer ce que l'on cherche.

Tout ce que j'ai trouvé, c'est une fonction pour mettre un pixel dans un pixbuf :

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
 
void put_pixel (GdkPixbuf *pixbuf, int x, int y, guchar red, guchar green, guchar blue, guchar alpha)
{
  int width, height, rowstride, n_channels;
  guchar *pixels, *p;
  n_channels = gdk_pixbuf_get_n_channels (pixbuf);
  g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
  g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
  g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
  g_assert (n_channels == 4);
  width = gdk_pixbuf_get_width (pixbuf);
  height = gdk_pixbuf_get_height (pixbuf);
  g_assert (x >= 0 && x < width);
  g_assert (y >= 0 && y < height);
  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
  pixels = gdk_pixbuf_get_pixels (pixbuf);
  p = pixels + y * rowstride + x * n_channels;
  p[0] = red;
  p[1] = green;
  p[2] = blue;
  p[3] = alpha;
}

Mais j'arrive pas à comprendre ce que l'on récupére et comment on le manie

Et même si je voulais utiliser aveuglément la fonction, bah la je sais modifier les données d'un pixel, mais pas les obtenir.

Si quelqu'un voit de quoi il retourne, merci d'avance de m'expliquer

Skip

[gerald3d]

Imaginons une image de 10x10. Ton GdkPixbuf contiendra un tableau de guchar de 10x10=100 pixels. Jusque là pas de pb.
Maintenant chaque pixel est codé en mode RVB. Pour chaque composante on utilise un octet. Donc 3 octets par pixels. Ce qui nous fait réellement un tableau de guchar de 10x10x3=300 octets.

Bon ensuite comment lit-on ce tableau?

Tous les pixels sont placés les uns à la suite des autres. Donc pour accéder à un pixel tu devras calculer sa position dans le tableau.

Soit le pixel P(x,y). Comme chaque pixel est codé avec 3 octets il faudra déjà multiplier les abscisses par 3. Ensuite si je veux le pixel de la deuxième ligne, il faudra compter tous les octets de la première ligne pour accéder à la deuxième.

Revenons à notre exemple.

• Donc l'axe des abscisses est égal à l'abscisse x de P multiplié par le nbre d'octet par pixel, ici 3.
• Pour l'axe des ordonnées, il faudra prendre le nbre d'octets par ligne multiplié par y du point P.

Ce qui nous donne en fin de compte :
Tableau[ (x*3) + (y*3*width) ] = p(x,y). Avec width la longueur en pixel de l'image.

Tableau est le pointeur que tu récupères avec la fonction gdk_pixbuf_get_pixels();

Maintenant que tu sais ca, tu peux utiliser la fonction de la doc. officielle. J'ai de mon côté donné il y a peu dans un autre post une fonction perso qui permet justement de récupérer le pixel et ses composantes couleurs en fonction de ses coordonnées : ici.

Remarque:
Jusqu'ici j'ai parlé d'un pixel codé en mode RVB. Mais il existe un autre mode, RVBA. La seule différence est qu'on ajoute un 4ème octet par pixel. Il correspond à une couleur de transparence. Si tu en a besoin il te suffit de reprendre la formule de dessus et de multiplier par 4 au lieu de 3.

[skip78]

Merci de ta réponse.

Grace à ton explication, j'ai compris comment ca fonctionnait, c'est deja une trés bonne chose de faite

Maintenant, j'ai deux questions :

1/ Comment manipuler les guchar (existe t-il une sorte de atoi pour pouvoir exploiter la valeur numérique de chaque composante ?)

2/ Comment savoir si l'image que l'utilisateur choisi est en RGB ou RGBA ? (j'imagine que les images sont par defaut en RGBA ?)

Merci encore,
Skip

[gerald3d]

Un guchar est un unsigned char. Un donnée comprise entre 0 et 255 strictement positive ou nulle. Maintenant ta question me fait dire que tu confonds pointeur et donnée.

Un tableau de guchar * est accessible de deux manières :

1. TABLEAU[x] = donnée numérique.
2. *(TABLEAU+x) = donnée numérique.

La deuxième méthode est moins utilisée pour cause de lecture peu claire. Donc en faisant TABLEAU[x] tu accédes directement à la donnée numérique d'une composante du pixel choisi.

Pour savoir si l'image est codée en RVB ou RVBA GdkPixbuf te fournis 2 fonctions :

Code :

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

1
2
3
4
5
6
7
8
9
gboolean            gdk_pixbuf_get_has_alpha            (const GdkPixbuf *pixbuf);
 
Queries whether a pixbuf has an alpha channel (opacity information).
 
pixbuf :
	A pixbuf.
 
Returns :
	TRUE if it has an alpha channel, FALSE otherwise.

Code :

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

1
2
3
4
5
6
7
8
9
int                 gdk_pixbuf_get_n_channels           (const GdkPixbuf *pixbuf);
 
Queries the number of channels of a pixbuf.
 
pixbuf :
	A pixbuf.
 
Returns :
	Number of channels.

Un jeu d'enfant

[skip78]

Ah oki merci

Tout simplement un octet, comme tu l'avais expliqué ^^

Bon bah désolé pour la redondance, je m'y met de suite, et si par malheur je rencontre un probleme, je viendrais quand même t'embeter un peu

Merci encore, tu peux pas savoir à quel point c'est agréable de pouvoir se faire aider aussi rapidement

En éspérant te renvoyer un jour l'ascenceur !

Skip

[gerald3d]

De rien. C'est avec plaisir...