Discussion :

[teuf13]

J'ai corriger mon code sa marche et je pensse avoir compris t'on explication.
Pour les red green blue ses normal de ne pas envoyé leur adresse car on ne veut pas les modifier on veut modifier le pixbuf et il n'ont rien avoir avec le pixbuf.

Oui voilà, ce n'est pourtant pas ce que tu avais fait au début :p

Par contre se que j'ai pas compris ses pourquoi on utilise pas de &pixbuf quant on l'envoi à la fonction car on veut modifier le pixbuf et non une copie de se pixbuf et comme se pixbuf à été déclaré en dehors de la fonctions logiquement on devrais envoyé sont adresse à la fonction.

Il ne faut pas perdre de vue que tu manipules tout le temps des pointeurs sur des GdkPixbuf, ie des GdkPixbuf*. Donc en passant "pixbuf" en argument à une fonction qui prend un GdkPixbuf*, tu n'as pas de copie de la structure GdkPixbuf qui est fait, uniquement une copie du pointeur, mais tu manipules quand même le même objet. Donc en passant un GdkPixbuf* en argument, tu peux modifier sans problème le contenu de la structure GdkPixbuf correspondante.

[grex1]

Je vient de modifier le code pour l'ajouter dans la fonction modifier pixel.
Sa marche mais je préfaire montrer le code au cas ou j'ai oublier qu'elle que chose :

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#include <stdlib.h>
#include <gtk/gtk.h>
#include <string.h>
 
 
void modifierpixel(GtkWidget *pButton, gpointer data);
gboolean gdkpixbuf_get_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar *red, guchar *green, guchar *blue);
gboolean gdkpixbuf_set_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar  red, guchar  green, guchar  blue);
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
      GtkWidget *pHBox;
       GtkWidget *pLabel;
    GtkWidget *pImage;
 
 
 
        GtkWidget *bouton;
 
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Les GtkBox");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 200, 400);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 pLabel=gtk_label_new("");
 
pImage = gtk_image_new_from_file("image.bmp");
 
 
 
  bouton = gtk_button_new_with_label("Modifier pixel");
 
    /* Creation de la GtkBox verticale */
    pVBox = gtk_vbox_new(FALSE, 0);
 
    /* Creation de la GtkHox verticale */
    pHBox = gtk_vbox_new(FALSE, 0);
 
    /* Ajout de la GtkVBox dans la fenetre */
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
 
 
gtk_box_pack_start(GTK_BOX(pVBox),pHBox, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pHBox),bouton, FALSE, FALSE, 0);
        gtk_box_pack_start(GTK_BOX(pVBox),pImage, TRUE, TRUE, 0);
         gtk_box_pack_start(GTK_BOX(pVBox),pLabel, TRUE, TRUE, 0);
 
      /* Connexions des signaux: */
 
 
 
 
    /* Connexion du signal "clicked" du GtkButton */
    g_signal_connect(G_OBJECT(bouton), "clicked", G_CALLBACK(modifierpixel), (GtkWidget*)  pImage);
 
 
 
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
 
 
/* Fonction callback executee lors du signal "clicked" */
void modifierpixel(GtkWidget *pButton, gpointer data)
{
      GdkPixbuf *pixbuf;
	pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(data));
 
 
 
guchar red, green, blue;
 
 
gint x=0,y=0;
 
gdkpixbuf_get_colors_by_coordinates(pixbuf, x, y,&red,&green,&blue);
 
while(x!=200)
{
 x++;
 if(x==199)
 {
     x=0;
     y++;
 }
 
 if(y==200)
 {
 
  x=200;
 }
        blue=255;
    red=0;
    green=0;
 
    gdkpixbuf_set_colors_by_coordinates(pixbuf, x, y,red,green,blue);
 
}
 
 
		gtk_image_set_from_pixbuf(GTK_IMAGE(data), pixbuf);
 
 
 
 
}
 
gboolean gdkpixbuf_get_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar *red, guchar *green, guchar *blue)
{
  guchar *pixel=NULL;
  gint channel=0;
  gint rowstride=0;
 
  if (!pixbuf) return FALSE;
  if (x<0 || y<0) return FALSE;
  if (x>gdk_pixbuf_get_width(pixbuf)) return FALSE;
  if (y>gdk_pixbuf_get_height(pixbuf)) return FALSE;
 
  pixel=gdk_pixbuf_get_pixels(pixbuf);
  channel=gdk_pixbuf_get_n_channels(pixbuf);
  rowstride=gdk_pixbuf_get_rowstride(pixbuf);
 
  *red   = pixel[(x*channel)+(y*rowstride)];
  *green = pixel[(x*channel)+(y*rowstride)+1];
  *blue  = pixel[(x*channel)+(y*rowstride)+2];
 
  return TRUE;
}
 
gboolean gdkpixbuf_set_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar red, guchar green, guchar blue)
{
  guchar *pixel=NULL;
  gint channel=0;
  gint width=0;
 
  if (!pixbuf) return FALSE;
  if (x<0 || y<0) return FALSE;
  if (x>gdk_pixbuf_get_width(pixbuf)) return FALSE;
  if (y>gdk_pixbuf_get_height(pixbuf)) return FALSE;
 
  pixel=gdk_pixbuf_get_pixels(pixbuf);
  channel=gdk_pixbuf_get_n_channels(pixbuf);
  width=gdk_pixbuf_get_width(pixbuf);
 
  pixel[(x*channel)+(y*width*channel)]   = red;
  pixel[(x*channel)+(y*width*channel)+1] = green;
  pixel[(x*channel)+(y*width*channel)+2] = blue;
 
  return TRUE;
}

[teuf13]

Il faut changer les *channels*width dans ta fonction set_colors par des *rowstride comme je l'ai fait dans la fonction get_colors.

Appeler pHBox une GtkVBox, ça prête à confusion.

J'ai l'impression que ta boucle while pourrait avantageusement être remplacée par 2 boucles for imbriquées :

Code :

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

1
2
3
4
5
6
 
for (x = 0; x < 200; x++) {
    for (y = 0; y < 200; y++) {
        /* do something */
    }
}

[grex1]

Pour les *rowstride bien que j'ai pas compris à quoi sa saire ses corriger.
Pour en savoir plus sur les gdkpixbuf j'ésite à acheter se livre :
[ame="http://www.amazon.fr/gp/product/toc/221209115X/ref=dp_toc/279-5929320-5578702?ie=UTF8&n=301061"]Programmation Linux avec GTK+: Amazon.fr: David Odin: Livres@@AMEPARAM@@http://ecx.images-amazon.com/images/I/5101HHKYB1L.@@AMEPARAM@@5101HHKYB1L[/ame]
Mais comme il est assé vieux aisse que la partit sur gdk est toujour valable?

[liberforce]

Bon, j'ai enfin retrouvé cet exemple d'utilisation de GdkPixbuf. Il se trouve dans la doc officielle.

The following code illustrates a simple put_pixel() function for RGB pixbufs with 8 bits per channel with an alpha channel. It is not included in the gdk-pixbuf library for performance reasons; rather than making several function calls for each pixel, your own code can take shortcuts.

Traduction:

Le code suivant illustre une fonction simple nommée put_pixel pour les pixbufs avec 8 bits par canal et un canal pour la couche alpha. Il n'est pas inclus dans la bibliothèque gdk-pixbuf pour des raisons de performances; plutôt que de faire plusieurs appels à la fonction (un par pixel), votre code peut prendre des raccourcis.

Cette fonction change la couleur d'un pixel se trouvant aux coordonnées (x, y). C'est complètement sous-optimal et lent, mais ça fera le boulot. Il suffit donc de récupérer l'état de chaque pixel, et si le pixel est noir, appeler put_pixel avec les mêmes coordonnées, et la couleur souhaitée.

Pour ce qui est de la rowstride, c'est la longueur en octets d'une ligne de pixels. En RGB (sans transparence, donc), tu as 3 canaux: le canal R (rouge), le canal G (vert) et le canal B (bleu). En RGBA tu as aussi le canal A (alpha) qui donne les informations de transparence. Chaque pixel prend 8 bits par canal, GdkPixbuf ne sait pas gérer autre chose. En RGB on a donc 1 pixel = 3 octets.

Mais les processeurs ont des contraintes d'alignement: certaines données doivent se trouver alignées sur un "mot" processeur. Si on a une image qui correspond à 2 lignes de 3 pixel, on a donc chaque ligne qui fait 3 x 3 = 9 octets en théorie. Mais pour respecter les contraintes d'alignement, il va souvent y avoir 12 octets pour la première ligne. On a ainsi un multiple de 32 bits, plus facilement manipulable par un processeur 32 bits. Mais qu'est-ce qu'il y a dans ces 3 octets à la fin qui sont rajoutés ? Bin rien. Ou plutôt n'importe quoi. Et ce n'importe quoi, on appelle ça le "padding". C'est juste du "remplissage", pour combler les trous.

Comme tu connais la largeur de l'image, et le nombre de canaux utilisés (3 en RGB, 4 en RGBA), tu peux en faisant la différence avec la rowstride, savoir combien d'octets de padding tu as à la fin de chaque ligne. Attention, un piège est que la dernière ligne ne contient jamais de padding. Cela permet d'éviter d'utiliser de la mémoire en plus pour rien.

Il ne te reste plus pour explorer ton image qu'à :

1. calculer la taille du padding en octets
2. faire une boucle pour explorer les lignes
3. faire une boucle à l'intérieur de la première pour explorer les colonnes
4. une fois une ligne explorée, il te suffit d'ajouter la valeur du padding pour passer à la ligne suivante.
5. une fois un pixel exploré, on peut passer au suivant en ajoutant le nombre d'octets qu'occupe un pixel. Celui ci correspond au nombre de canaux (renvoyé par gdk_pixbuf_get_n_channels), multiplié par la taille (en octets) de chaque échantillon (information renvoyée par gdk_pixbuf_get_bits_per_sample à un facteur 8 près : la fonction renvoie un nombre de bits et tu as besoin d'un nombre d'octets)

Tu peux aussi si tu ne souhaites pas parcourir tous les pixels, calculer la position d'un pixel (x,y) dans le buffer de la manière suivante:
p = y * (longueur_d'une_ligne_en_octets) + x

Et devine à quoi correspond longueur_d'une_ligne_en_octets ? Et réfléchis stp au lieu de poser la question...

[liberforce]

Pour les *rowstride bien que j'ai pas compris à quoi sa saire ses corriger.
Pour en savoir plus sur les gdkpixbuf j'ésite à acheter se livre :
Programmation Linux avec GTK+: Amazon.fr: David Odin: Livres
Mais comme il est assé vieux aisse que la partit sur gdk est toujour valable?

Franchement, si c'est pour la partie sur GDK, alors je te le déconseille. De toute façon, toute la partie de dessin avec GDK va tout bonnement disparaître dans la dernière version de GTK2, et dans la première version de GTK3, remplacée par cairo. GdkPixbuf sera encore dedans, je pense, mais tout ce qui concerne le dessin de formes avec GDK sera rendu obsolète...

[grex1]

Pour l'exemple de gdkPixbuf j'utilise déjà les fonctions de la FAQ qui on été corriger par teuf13.
Par contre elle ne renvois pas le canal alpha sa serai possible de les modifier pour qu'elle praine en conte se canal?
Et pour le livre bien qu'il y est des tas de fonction obsolete aisse qu'il y en a aussi aussi qui sont toujour valable aujourdhui?
Comme je connais pas l'anglais et qu'il n'y a aucun livre a jour est aucun tutorial en francais sur gdk même si il y à beauoup de fonction obsolete peut être que sa serai la seul façon que j'ai d'en savoir plus sur gdk pixbuf.
Il suffis qu'on me dise qu'elle sont les fonctions du livre toujour valable est sa serai mieux que rien.
Apres si vous conaissez d'autre livre en francais un peux plus complet sur gdk pixbuf ou cairo sa pourré aussi être une solution.

[teuf13]

Pour des trucs un peu pointus/bas niveau comme cairo ou les GdkPixbuf, tu risques de rapidement te retrouver bloqué dans ta progression si tu refuses absolument d'approcher toute doc en anglais.

[grex1]

Ses pas que je refuse, ses que je suis incapable d'apprendre l'anglais.
Et puis ses déja tres bien pour un dyslexique grave de settre mis a la programmation.
Surtout que le coté orienté objet de la GTK sa m'a caussé beaucoup de probleme ,la façon dont est organiser le code ses vrément pas fait pour les dyslexiques.
Donc je sais que je suis bloqué d'en ma prograssion et je peut rien y faire la seul chiose que je peut faire ses éssayé de prendre le peux d'info que j'ai en francais pour ésayé de faire beaucoup avec peu.
D'ailleur einstane(il été aussi dyslexique) disé"l'imagination est plus importente que la conaisance".
A par sa ses possible de modifier la fonction pour qu'elle praine en conte le canal alpha?

[teuf13]

Je sais pas, j'ai un ami qui fait de la dyslexie aussi, et il est très bon en programmation. C'est peut être beaucoup plus léger chez lui que chez toi. Note que je n'ai pas dit "refuser d'apprendre l'anglais", j'ai dit "refuser d'approcher une doc en anglais", sans parler couramment anglais, c'est peut être possible de comprendre quelques mots. Et même sans ça, quelle que soit la langue de la doc, les exemples de code devraient toujours être compréhensibles. Et google translate doit pouvoir être très utile dans certains cas (je ne sais pas ce qu'il peut donner sur des textes très techniques).

Pour ta question sur le canal alpha, il faudrait être plus précis, je ne sais pas trop ce que tu demandes.

[grex1]

Cette ami sa serais possible de communiquer avec lui par mail?(j'émerai discuter de dyslexie).
J'ai déjà essayé google traduction mais sa traduit pas très bien et la doc n'est pas très clair.
il y a plun de code de fonction avec de petite explication mis n'importe comment.
Se qu'il aurai fallut ses un vrais Tutorial la ses comme si on te donné une recette de cuisine ou il y aurrai que la liste des ingrédients sens savoir dans qu'elle ordre on doit les utiliser.
Mais si t'a un tutoriel en anglais autre que la doc mieux expliqué avec google traduction sa pourrai peut être allé.
Pour le canal alpha je veut dire par la que en plus des couleurs j'émerai avoir la valeur de alpha.
J'émerai pouvoir modifier un pixel sens le modifier complètement en ajoutent une couleur alpha(degres de transparence) de cette fasson:

Code :

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

gdkpixbuf_set_colors_by_coordinates(pixbuf, x, y,red,green,blue,alpha);

[liberforce]

Ecoute, le problème ce n'est plus une question d'anglais de dyslexie ou autre. Le problème c'est que pour faire ce que tu demandes il y a 2 lignes à changer (dont le prototype que tu as déjà modifié par toi même), et que si tu avais lu et compris ce que je t'ai écrit (en français) sur comment fonctionne en interne un GdkPixbuf, tu serais capable de faire toi même la modification. J'en conclus donc que tu demandes beaucoup aux autres, mais ne te remets pas en question.

Mon conseil: prends un bouquin de C en français, exerce toi, et un fois que tu auras compris, alors remets toi à GTK. On n'apprend pas à courir avant d'avoir appris à marcher.

Pour le moment, tu ne formules pas tes questions pour comprendre, tu formules les questions pour qu'on fasse à ta place. Et au bout d'un moment, cela devient passablement irritant. Je veux bien que tu sois dyslexique, que tu aies des difficultés. Mais si tu ne fais pas la démarche d'apprendre à poser les bonnes questions, ni d'écouter ce qu'on te dit, tu ne progresseras pas. Même un tutoriel ne t'avancerait pas, parce qu'un tutoriel ne couvrira jamais 100% de tes attentes. Celui qui l'écrit ne peut pas deviner ce que tu veux faire, il peut juste se contenter d'un exemple.

Si tu n'as pas compris mon précédent message, alors indique ce que tu n'as pas compris. Mais par pitié, fais des efforts pour essayer de comprendre ce qu'on t'écrit avant de dire "je veux faire ça, comment on fait ?".

Ah au fait, si tu avais essayé de lire l'exemple de code de la doc officielle (dont je t'ai donné le lien plus haut), tu aurais réalisé qu'il fait exactement ce que tu veux faire dans ta fonction gdkpixbuf_set_colors_by_coordinates.

[grex1]

Pour la fonction put_pixel j'ai déjà tenté de l'utiliser et j'ai se message d'erreur: assertion failed: (gdk_pixbuf_get_has_alpha(pixbuf))
Pour se qui est de comprendre comment sa fonctionne à l'intérieur de de la fonction j'ai déjà tenté de comprendre t'est explication mais sa fait beaucoup trôs de chose à assimilé d'un coup et ses pas toujours très claire.
Et puis pour reprendre t'a métaphore:
on est pas obligé d'apprendre ou comprendre par coueur la loi de la gravitation universelle pour pouvoir commencer à marcher(même si ses intéressant).
Quant j'aurré la tête plus reposé je t'expliquerai la ou je coince en regardent plus en détaille mais j'émerai pouvoir utiliser cette fonction maintenant et connaitre par coueur son fonctionnement se n'est pas indispensable.

J'émerai juste que tu ajoute l'une des 2 lignes de ce cette fonction :gdkpixbuf_set_colors_by_coordinates.
Pour l'un de ses ses 2 lignes j'ai déjà ma petite idée:

Code :

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

 pixel[(x*channel)+(y*rowstride)+3] = alpha;

Ou alors si put_pixel est mieux explique moi comment s'en servire.

[liberforce]

g_assert vérifie si une condition est vraie, et si elle ne l'est pas, il arrête brutalement le programme. C'est utilisé pour trouver les erreurs de programmations. L'avantage c'est qu'au lieu de crasher n'importe où tu sais exactement ce qui fait que l'application ne fonctionne pas. En l'occurrence, là il te que la fonction gdk_pixbuf_get_has_alpha(pixbuf) n'a pas renvoyé "true" (vrai) comme il l'attendait. Et cette fonction ne renvoie vrai que quand le pixbuf contient un canal alpha. Cela veut donc juste dire que tu as chargé une image sans transparence.

Tu auras le même soucis avec la ligne:

Code :

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

g_assert (n_channels == 4)

qui vérifie que l'image chargée possède bien 4 canaux (du RGBA quoi...)

Utilise donc une image de test en PNG avec de la transparence, et ça passera. N'utilise pas un jpg, ce format ne gère pas la transparence.

Pour ce qui est de la dernière ligne manquante, c'est correct. Et si tu veux modifier put_pixel pour gérer les images en RGB et RGBA, tu n'as qu'à faire une variante RGB et RGBA (le put_pixel) et appeler l'un ou l'autre selon qu'un canal alpha est présent ou non, ou bien juste modifier put_pixel pour qu'elle ignore le canal alpha s'il n'est pas présent (ce qui sera sans doute plus joli et simple).

Si tu as du mal avec l'anglais, alors tu n'as qu'à écrire du pseudo code en français, ne serait-ce que pour voir si tu as bien compris l'algorithme.

[grex1]

En fait comme tu vient de me l'expliquer si il n'y a pas de canal alpha dans l'image il suffi de retiré ses 2 assertions(g_assert (n_channels == 4), gdk_pixbuf_get_has_alpha(pixbuf)) comme sa sa modifi l'image quant même même sen prendre en conte de canal alpha quant il n'y en a pas.
Par contre pourquoi on utilise 2 assertions qui donne le même résultat une seul ses largement suffisant?
Mais en fait se que j'aurrai voullu ses pouvoir ajouter d'autre pixel qui on un canal alpha par dessus se déjà existent.
M'est pour sa je suppose qu'il faut créer un autre pixbuf qu'on colle par dessus se que je ne c'est pas faire.

[liberforce]

En fait comme tu vient de me l'expliquer si il n'y a pas de canal alpha dans l'image il suffi de retiré ses 2 assertions(g_assert (n_channels == 4), gdk_pixbuf_get_has_alpha(pixbuf)) comme sa sa modifi l'image quant même même sen prendre en conte de canal alpha quant il n'y en a pas.

Non, cela ne suffit pas. Si tu ne fait que cela, ton programme peut planter à l'exécution de la ligne

Code :

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

p[3] = alpha;

. Cette ligne ne doit être exécutée que si un canal alpha existe.

Par contre pourquoi on utilise 2 assertions qui donne le même résultat une seul ses largement suffisant?

En fait je pense que c'est parce qu'ils prévoyaient le cas d'autres espaces de couleur. Par exemple, imagine le cas d'une image en niveaux de gris (greyscale), avec un canal alpha. On aurait donc 1 canal couleur et 1 canal alpha, et donc tester la présence d'un canal alpha et le nombre de canaux séparément aurait un sens. Sauf qu'en pratique, les espaces autres que RGB (avec et sans canal alpha) n'ont jamais été implémentés, donc effectivement, si tu as un canal alpha, c'est que tu es forcément en RGBA et donc que tu as 4 canaux.

De même, la fonction gdk_pixbuf_get_bits_per_sample donne la taille d'un échantillon dans un canal pour un pixel. En pratique, seuls les échantillons 8bits ont été implémentés. Un pixel prend donc 3 octets (3 canaux × 8 bits) en RGB, ou 4 octets (4 canaux × 8 bits) en RGB. Mais si gdk_pixbuf avait su gérer les canaux 16 bits, leur code serait faux.

Mais en fait se que j'aurrai voullu ses pouvoir ajouter d'autre pixel qui on un canal alpha par dessus se déjà existent.
M'est pour sa je suppose qu'il faut créer un autre pixbuf qu'on colle par dessus se que je ne c'est pas faire.

La en revanche, je ne comprends pas trop ce que tu veux faire. Je croyais qu'au départ tu voulais juste changer les pixels noirs en rouge ?

[liberforce]

Bon, j'ai écrit un exemple qui colorie les pixels d'une image appelée "test.png" du noir vers le rouge. Pas le temps de mettre des commentaires, mais le code est assez parlant, et la fonction qui colorie est largement inspirée de put_pixel... A gauche j'affiche l'image d'origine, à droite l'image modifiée.

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
#include <gtk/gtk.h>
#include <gdk-pixbuf/gdk-pixbuf.h>
#include <gdk/gdkevents.h>
 
typedef struct
{
	GtkWidget *main_window;
	GtkWidget *original;
	GtkWidget *colorized;
} ImageViewerGui;
 
void
on_destroy (GtkObject *object, gpointer user_data)
{
	gtk_main_quit ();
}
 
void 
gdk_pixbuf_replace_color (GdkPixbuf *pixbuf, 
		guchar old_red, guchar old_green, guchar old_blue,
		guchar new_red, guchar new_green, guchar new_blue)
{
	int width, height, rowstride, n_channels;
	guchar *pixels, *p;
	guint x, y;
 
	g_assert (pixbuf != NULL);
	g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
	g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
 
	n_channels = gdk_pixbuf_get_n_channels (pixbuf);
	width = gdk_pixbuf_get_width (pixbuf);
	height = gdk_pixbuf_get_height (pixbuf);
	rowstride = gdk_pixbuf_get_rowstride (pixbuf);
	pixels = gdk_pixbuf_get_pixels (pixbuf);
 
	for (y = 0; y < height; y++)
	{
		for (x = 0; x < width; x++)
		{
			p = pixels + y * rowstride + x * n_channels;
			if (p[0] == old_red && p[1] == old_green && p[2] == old_blue)
			{
				p[0] = new_red;
				p[1] = new_green;
				p[2] = new_blue;
			}
		}
	}
}
 
int 
main (int argc, char* argv[])
{
	ImageViewerGui gui;
	GtkBuilder *builder;
	GError *error = NULL;
	GdkPixbuf *pixbuf;
 
	gtk_init (&argc, &argv);
 
	builder = gtk_builder_new ();
	gtk_builder_add_from_file (builder, "gdk-pixbuf-colorize.ui", &error);
	if (error != NULL)
	{
		g_error ("%s | %s", G_STRLOC, error->message);
		g_clear_error (&error);
	}
 
	gui.main_window = GTK_WIDGET (gtk_builder_get_object (builder, "window"));
	gui.original = GTK_WIDGET (gtk_builder_get_object (builder, "original-image"));
	gui.colorized = GTK_WIDGET (gtk_builder_get_object (builder, "colorized-image"));
 
 
	pixbuf = gtk_image_get_pixbuf (GTK_IMAGE (gui.colorized));
	gdk_pixbuf_replace_color (pixbuf, 
			0, 0, 0,    /* noir */
			255, 0, 0); /* rouge */
	gtk_widget_show_all (GTK_WIDGET (gui.main_window));
 
	/* Connect signals */
	g_signal_connect (G_OBJECT (gui.main_window), "destroy",
			G_CALLBACK (on_destroy), NULL);
 
	gtk_main();
	return 0;
}

[grex1]

Au début je voulais juste modifier tout les pixel de l'image en rouge mais quant j'ai vu le cana alpha sa m'a donné envie de mettre un rouge transparent.
Finalement ses possible sens canal alpha par contre je sais pas pourquoi sa marche pas avec les images bmp mais avec les jpg sa marche.

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
#include <stdlib.h>
#include <gtk/gtk.h>
#include <string.h>
 
 
void modifierpixel(GtkWidget *pButton, gpointer data);
 
void utiliserfiltre(GtkWidget *pButton, gpointer data);
gboolean gdkpixbuf_get_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar *red, guchar *green, guchar *blue);
static void put_pixel (GdkPixbuf *pixbuf, int x, int y, guchar red, guchar green, guchar blue, guchar alpha);
gboolean gdkpixbuf_set_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar  red, guchar  green, guchar  blue);
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
      GtkWidget *pHBox;
       GtkWidget *pLabel;
    GtkWidget *pImage;
 
 
 
        GtkWidget *bouton;
           GtkWidget *bouton2;
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Les GtkBox");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 200, 400);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
 pLabel=gtk_label_new("");
 
pImage = gtk_image_new_from_file("dyslexie18.jpg");
 
 
 
  bouton = gtk_button_new_with_label("Modifier pixel");
  bouton2 = gtk_button_new_with_label("filtre");
 
    /* Creation de la GtkBox verticale */
    pVBox = gtk_vbox_new(FALSE, 0);
 
    /* Creation de la GtkHox verticale */
    pHBox = gtk_hbox_new(FALSE, 0);
 
    /* Ajout de la GtkVBox dans la fenetre */
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
 
 
gtk_box_pack_start(GTK_BOX(pVBox),pHBox, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(pHBox),bouton, FALSE, FALSE, 0);
        gtk_box_pack_start(GTK_BOX(pHBox),bouton2, FALSE, FALSE, 0);
 
        gtk_box_pack_start(GTK_BOX(pVBox),pImage, TRUE, TRUE, 0);
         gtk_box_pack_start(GTK_BOX(pVBox),pLabel, TRUE, TRUE, 0);
 
      /* Connexions des signaux: */
 
 
 
 
    /* Connexion du signal "clicked" du GtkButton */
    g_signal_connect(G_OBJECT(bouton), "clicked", G_CALLBACK(modifierpixel), (GtkWidget*)  pImage);
 
    /* Connexion du signal "clicked" du GtkButton */
    g_signal_connect(G_OBJECT(bouton2), "clicked", G_CALLBACK(utiliserfiltre), (GtkWidget*)  pImage);
 
 
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
 
 
/* Fonction callback executee lors du signal "clicked" */
void modifierpixel(GtkWidget *pButton, gpointer data)
{
 
 GdkPixbuf *pixbuf;
	pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(data));
 
 
 
guchar red, green, blue,alpha;
red=0;
green=0;
blue=0;
 
char tableaured[1000],tableaugreen[1000],tableaublue[1000];
gint x=0,y=0;
 
 int sautligne=0;
 
for (y = 0; y < gdk_pixbuf_get_height(pixbuf); y++) {
    for (x = 0; x < gdk_pixbuf_get_width(pixbuf); x++) {
        /* do something */
 
        gdkpixbuf_get_colors_by_coordinates(pixbuf, x, y,&tableaured[x],&tableaugreen[x],&tableaublue[x]);
 
 
 
 
 
 
 
sautligne++;
if(sautligne>10)
{
 
put_pixel(pixbuf,x,y,tableaured[x],tableaugreen[x],tableaublue[x],alpha);
 
}
else
{
 
put_pixel(pixbuf,x,y,tableaured[x],green,blue,alpha);
 
}
 
if(sautligne==20)
{
   sautligne=0;
 
}
 
 
    }
}
 
 
 
 
 
		gtk_image_set_from_pixbuf(GTK_IMAGE(data), pixbuf);
 
 
 
 
 
}
 
 
 
void utiliserfiltre(GtkWidget *pButton, gpointer data)
{
      GdkPixbuf *pixbuf;
	pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(data));
 
 
 
guchar red, green, blue,alpha;
red=0;
green=0;
blue=0;
 
char tableaured[1000],tableaugreen[1000],tableaublue[1000];
gint x=0,y=0;
 
 int sautligne=0;
 
for (y = 0; y < gdk_pixbuf_get_height(pixbuf); y++) {
    for (x = 0; x < gdk_pixbuf_get_width(pixbuf); x++) {
        /* do something */
 
        gdkpixbuf_get_colors_by_coordinates(pixbuf, x, y,&tableaured[x],&tableaugreen[x],&tableaublue[x]);
 
        put_pixel(pixbuf,x,y,tableaured[x],green,blue,alpha);
 
 
 
 
    }
}
 
 
 
 
 
		gtk_image_set_from_pixbuf(GTK_IMAGE(data), pixbuf);
 
 
 
 
}
 
gboolean gdkpixbuf_get_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar *red, guchar *green, guchar *blue)
{
  guchar *pixel=NULL;
  gint channel=0;
  gint rowstride=0;
 
  if (!pixbuf) return FALSE;
  if (x<0 || y<0) return FALSE;
  if (x>gdk_pixbuf_get_width(pixbuf)) return FALSE;
  if (y>gdk_pixbuf_get_height(pixbuf)) return FALSE;
 
  pixel=gdk_pixbuf_get_pixels(pixbuf);
  channel=gdk_pixbuf_get_n_channels(pixbuf);
  rowstride=gdk_pixbuf_get_rowstride(pixbuf);
 
  *red   = pixel[(x*channel)+(y*rowstride)];
  *green = pixel[(x*channel)+(y*rowstride)+1];
  *blue  = pixel[(x*channel)+(y*rowstride)+2];
 
 
  return TRUE;
}
 
gboolean gdkpixbuf_set_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar red, guchar green, guchar blue)
{
  guchar *pixel=NULL;
  gint channel=0;
  gint rowstride=0;
 
  if (!pixbuf) return FALSE;
  if (x<0 || y<0) return FALSE;
  if (x>gdk_pixbuf_get_width(pixbuf)) return FALSE;
  if (y>gdk_pixbuf_get_height(pixbuf)) return FALSE;
 
  pixel=gdk_pixbuf_get_pixels(pixbuf);
  channel=gdk_pixbuf_get_n_channels(pixbuf);
 rowstride=gdk_pixbuf_get_rowstride(pixbuf);
 
  pixel[(x*channel)+(y*rowstride)] = red;
  pixel[(x*channel)+(y*rowstride)+1] = green;
  pixel[(x*channel)+(y*rowstride)+2] = blue;
 
 
  return TRUE;
}
 
static 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);
 
 
  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;
  if(n_channels == 4)
  {
  p[3] = alpha;
  }
}

Pour t'on code il ne marche pas avec moi car je n'utilise pas gtkbuilder mais se n'est pas grave j'ai créer un autre code qui marche(il reste juste a corriger le problème des bmp).
A par sa t'aurai pas un bon tutoriel autre que la doc?

[liberforce]

Pour t'on code il ne marche pas avec moi car je n'utilise pas gtkbuilder mais se n'est pas grave j'ai créer un autre code qui marche(il reste juste a corriger le problème des bmp).

Tu es optimiste... Ce que je vois est encore loin de marcher. Fais le test avec une image de plus de 1000 pixels, le programme plantera. Quant à ta variable saut de ligne, elle saute les pixels, pas les lignes. Ensuite, passer par des tableaux n'a aucun intérêt vu que tu traites les pixels un à un.

Et pourquoi tu ne peux pas exécuter mon exemple, ta version de gtk est trop ancienne ? Dans le fichier en téléchargement, il y a l'interface GtkBuilder correspondante, un Gtk pas trop ancien saura le lire. Et puis sinon il y a 3 widgets qui se battent en duel, je peux faire une version où l'interface graphique est faire "à la main".

A par sa t'aurai pas un bon tutoriel autre que la doc?

Non, pas de tutoriel GdkPixbuf en français, mais il ne te dirait rien de plus que ce que nous pouvons te dire...

Au fait, tu peux m'expliquer précisément ce que tes fonctions "modifierpixel" et "utiliserfiltre" sont censées faire ?

[grex1]

Pour les images de 1000 pixel ses juste que j'avais pas allouer assé de mémoire aux tableaux de couleur.
Pour le fait d'utiliser des tableaux pour l'instant je sais que sa n'a pas d'intérer, en fait si j'en est fait ses pour pouvoir créer par la suite un autre filtre ou je me saire des valeur des ensyin pixel pour savoir comment les attribuer au nouveau.
Pour saut ligne je suis déjà au courent et je sais comment y remédier ses juste que avent de travailler sur des lignes je voulais déjà m'exercer sur qu'elle que pixel.

Pour t'on code je vient de télécharger l'interphase il marche bien mais se qui me plais pas ses qu'il à été fait avec gtk builder donc j'y comprend pas grand chose.
Et puis si je doit je démarrer sur windows(pour l'instent j'utilise ubuntu) pour créer un exécutable avec innosetup sa risque de pas être pratique.
L'aventage de mon code ses que je le comprend plus facilement donc je peut le modifier et même si ils reste des petites erreur en les corrigent sa m'en apprend beaucoup plus qu'en utilisent un code tout près.
Par contre rien empaiche d'adapter des chose de t'on code vers le mien si tu m'explique de quoi il s'agis .

Pour ma fonction modifier pixel elle est juste sensés écrire des bande rouge transparente sur une image et pour la fonction utiliser filtre elle est juste sensé coloriser l'image en rouge de la même fasson mais en totalité.
C'est comme dans gimp quant on clique sur couleur et qu'en bas du menu déroulent on clique sur coloriser.
Mais si je fait sa ses pour m'entréné a comprendre comment fonctionne les pixels.
La le problème de mon code ses que avec les images jpg sa marche mais avec les bmp sa m'affiche par dessus un blanc transparent.

A par sa pour un tutorial t'en a pas un anglais mieux explique que la doc que je traduiré avec google traduction?
Il y à surement plun de truck que vous pouvais me dire mais sa m'embaitte de vous déranger tros souvent.
Surtout que j'émerai par la suite apprendre a bouger et coller des surfaces suivent un axe x y en gérent les évènement du clavier et de la souris comme avec la sdl.