Exemple de programme qui change tous les pixels noirs d'un GdkPixbuf en rouge

**grex1** · 18/08/2010, 01h28

Bonjour,
Je cherche à comprendre comment fonctionne les gtkpixbuf mais il y a très peut de documentation en français et je ne connais pas l'anglais.
Je suis dyslexique sété déjà dur pour moi de me mettre a la gtk alors ne me demander pas d'apprendre l'anglais.
Tout se que j'ai pus trouver en francais sur les gdkpixbuff
c'est:
http://gtk.developpez.com/faq/?page=gdkpixbuf

A cote de sa je connais un peu de chose sur les pixels
Comme il n'y a pas de tutorial en francais sur gtk pixbuff sa serai possible que vous me montrier juste un exemple de programme basic avec gdkpixbuff qui change tout les pixel noir d'une image en rouge?
Je vous demande pas un tutoriel, rien qu'en regardent le code je devrait être capable de comprendre pas mal de chose.

**teuf13** · 18/08/2010, 11h29

Hmm, la FAQ sur les GdkPixbuf de developpez.com sur laquelle tu donnes un lien à des exemples de code pour accéder aux composantes (R,G,B) d'un pixel situé à des coordonnées (X, Y), pour changer tous les pixels noirs en rouge, il te suffit de réutiliser ce code pour itérer sur l'intégralité de ton image, pour chaque pixel de tester s'il est noir (R, G, B) == (0, 0, 0) et de le remplacer par un pixel rouge (R, G, B) = (255, 0, 0)

Dans un premier temps, tu dois pouvoir te familiariser avec tout ça en créant un pixbuf tout noir, et en essayant de changer la couleur de pixels arbitraires.

Je sais pas si ces explications sont suffisammetn claires, n'hésite pas à poser des questions sur le code de la FAQ pour les choses qui te paraissent dures.

**grex1** · 18/08/2010, 14h09

Si je poste içi c'est justement par se que ses loin d'être clair.
J'ai déja tenté d'utiliser la fonction gdkpixbuf_get_colors_by_coordinates de differente fasson.
Mais à chaque fois j'ai un segmentation fault donc en gros je peut même pas récupéré les valeur RVB du pixel en haut a gauche que sa commence déjà à planté:

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
#include <stdlib.h>
#include <gtk/gtk.h>
 
void OnZoomIn(GtkWidget *pWidget, gpointer data);
void OnZoomOut(GtkWidget *pWidget, gpointer data);
void cassetoi(GtkWidget *pWidget, gpointer data);
gboolean gdkpixbuf_get_colors_by_coordinates(GdkPixbuf *pixbuf, gint x, gint y, guchar *red, guchar *green, guchar *blue);
 
int main(int argc, char **argv)
{
	GtkWidget *pWindow;
	GtkWidget *pBox;
	GtkWidget *pBox2;
	GtkWidget *pZoomIn;
	GtkWidget *pZoomOut;
    GtkWidget *cassepixel;
	GtkWidget *pScrolled;
	GtkWidget *pImage;
 
	gtk_init(&argc, &argv);
 
	pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_default_size(GTK_WINDOW(pWindow), 500, 500);
	g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
	pBox = gtk_vbox_new(FALSE, 5);
	gtk_container_add(GTK_CONTAINER(pWindow), pBox);
 
	pBox2 = gtk_hbox_new(TRUE, 5);
	gtk_box_pack_start(GTK_BOX(pBox), pBox2, FALSE, FALSE, 0);
 
	pZoomIn = gtk_button_new_from_stock(GTK_STOCK_ZOOM_IN);
	gtk_box_pack_start(GTK_BOX(pBox2), pZoomIn, TRUE, TRUE, 0);
	pZoomOut = gtk_button_new_from_stock(GTK_STOCK_ZOOM_OUT);
	gtk_box_pack_start(GTK_BOX(pBox2), pZoomOut, TRUE, TRUE, 0);
	   cassepixel = gtk_button_new_with_label("cassepixel");
gtk_box_pack_start(GTK_BOX(pBox2), cassepixel, TRUE, TRUE, 0);
 
	pScrolled = gtk_scrolled_window_new(NULL, NULL);
	gtk_box_pack_start(GTK_BOX(pBox), pScrolled, TRUE, TRUE, 0);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrolled), GTK_POLICY_ALWAYS, GTK_POLICY_ALWAYS);
 
	pImage = gtk_image_new_from_file("imagedetest.png");
	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pScrolled), pImage);
 
	g_signal_connect(G_OBJECT(pZoomIn), "clicked", G_CALLBACK(OnZoomIn), pImage);
	g_signal_connect(G_OBJECT(pZoomOut), "clicked", G_CALLBACK(OnZoomOut), pImage);
    g_signal_connect(G_OBJECT(cassepixel), "clicked", G_CALLBACK(cassetoi), pImage);
 
	gtk_widget_show_all(pWindow);
 
	gtk_main();
 
	return EXIT_SUCCESS;
}
 
void OnZoomIn(GtkWidget *pWidget, gpointer data)
{
	GdkPixbuf *pSrcPixbuf, *pDestPixbuf;
	gint iWidth, iHeight;
 
	// Recuperation du GdkPixbuf //
	pSrcPixbuf = gtk_image_get_pixbuf(GTK_IMAGE(data));
	// Recuperation de la taille de l'image //
	iWidth = gdk_pixbuf_get_width(pSrcPixbuf);
	iHeight = gdk_pixbuf_get_height(pSrcPixbuf);
	// Creation du nouveau GdkPixbuf //
	pDestPixbuf = gdk_pixbuf_scale_simple(pSrcPixbuf, iWidth+10, iHeight+10, GDK_INTERP_NEAREST);
	// Remplacement de l'ancien GdkPixbuf par le nouveau //
	gtk_image_set_from_pixbuf(GTK_IMAGE(data), pDestPixbuf);
 
	g_object_unref(pDestPixbuf);
}
 
void OnZoomOut(GtkWidget *pWidget, gpointer data)
{
	GdkPixbuf *pSrcPixbuf, *pDestPixbuf;
	gint iWidth, iHeight;
 
	// Recuperation du GdkPixbuf //
	pSrcPixbuf = gtk_image_get_pixbuf(GTK_IMAGE(data));
	// Recuperation de la taille de l'image //
	iWidth = gdk_pixbuf_get_width(pSrcPixbuf);
	iHeight = gdk_pixbuf_get_height(pSrcPixbuf);
	// Creation du nouveau GdkPixbuf //
	pDestPixbuf = gdk_pixbuf_scale_simple(pSrcPixbuf, iWidth-10, iHeight-10, GDK_INTERP_NEAREST);
	// Remplacement de l'ancien GdkPixbuf par le nouveau //
	gtk_image_set_from_pixbuf(GTK_IMAGE(data), pDestPixbuf);
 
	g_object_unref(pDestPixbuf);
}
 
void cassetoi(GtkWidget *pWidget, gpointer data)
{
	GdkPixbuf *pSrcPixbuf, *pDestPixbuf;
	gint iWidth, iHeight;
 
	// Recuperation du GdkPixbuf //
	pSrcPixbuf = gtk_image_get_pixbuf(GTK_IMAGE(data));
 
 
guchar *red=NULL, *green=NULL, *blue=NULL;
 
 
gint x=0,y=0;
 
guchar *putaindepixel=gdkpixbuf_get_colors_by_coordinates(pSrcPixbuf, x, y,red,green,blue);
 
 
 
	// Remplacement de l'ancien GdkPixbuf par le nouveau //
	gtk_image_set_from_pixbuf(GTK_IMAGE(data), pDestPixbuf);
 
	g_object_unref(pDestPixbuf);
}
 
 
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 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);
 
  *red   = pixel[(x*channel)+(y*width*channel)];
  *green = pixel[(x*channel)+(y*width*channel)+1];
  *blue  = pixel[(x*channel)+(y*width*channel)+2];
 
  return TRUE;
}

**teuf13** · 18/08/2010, 14h19

Oula, c'est gros ce code. Tu pourrais déjà commencer par jouer avec

Code :

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

1
2
3
4
 
gtk_init(..);
pixbuf = gdk_pixbuf_new_from_file (...);
gdkpixbuf_get_colors_by_coordinates (pixbuf...);

**grex1** · 18/08/2010, 14h34

Pour le pixbuf = gdk_pixbuf_new_from_file (...); il a déjà été utiliser dans la fonction main est envoyé à la fonction cassetoi.
Pour le gdkpixbuf_get_colors_by_coordinates (pixbuf...); cette fonction se trouve dans la fonction cassetoi mais je n'arrive pas à l'utiliser correctement.
Se code est grand mais je le comprend, j'ai fait que réutiliser un code que j'ai modifier pour y mettre un bouton qui maine la fonction casse toi sensés récupéré un pixel grasse à gdkpixbuf_get_colors_by_coordinates mais tout plante.

**teuf13** · 18/08/2010, 14h56

Envoyé par grex1

Se code est grand mais je le comprend, j'ai fait que réutiliser un code que j'ai modifier pour y mettre un bouton qui maine la fonction casse toi sensés récupéré un pixel grasse à gdkpixbuf_get_colors_by_coordinates mais tout plante.

Justement, "tout plante", sans que tu saches trop d'où vient le problème. Si tu repars d'un code minimal pour expérimenter et comprendre pourquoi ça plante, ça permet de limiter les endroits où le plantage risque de se produire, donc ça simplifie grandement les choses et la compréhension.

**grex1** · 18/08/2010, 15h40

J'ai refait un nouveau code minimal ou j'ai prevu une fonction modifier pixel que je pré-faire laisser vide pour l'instant.

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
 
#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);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
      GtkWidget *pHBox;
    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);
 
 
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);
 
 
guchar *red=NULL, *green=NULL, *blue=NULL;
 
 
gint x=0,y=0;
 
guchar *putaindepixel=gdkpixbuf_get_colors_by_coordinates(pImage, x, y,red,green,blue);
 
 
 
 
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);
 
      /* Connexions des signaux: */
 
 
 
    /* Connexion du signal "clicked" du GtkButton */
    g_signal_connect(G_OBJECT(bouton), "clicked", G_CALLBACK(modifierpixel), (GtkWidget*) pVBox);
 
 
 
 
 
 
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
 
 
/* Fonction callback executee lors du signal "clicked" */
void modifierpixel(GtkWidget *pButton, gpointer data)
{
 
 
 
 
}
 
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 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);
 
  *red   = pixel[(x*channel)+(y*width*channel)];
  *green = pixel[(x*channel)+(y*width*channel)+1];
  *blue  = pixel[(x*channel)+(y*width*channel)+2];
 
  return TRUE;
}

Cette foi si j'ai une erreur dans la console:
GDKPixbuf-CRITICAL **: gdk_pixbuf_get_width: assertion ' GD K_ISPIXBUF(pixbuf)' failed

**teuf13** · 18/08/2010, 16h10

Ca veut dire que quelque part tu manipules un pointeur en considérant qu'il contient un GdkPixbuf alors qu'en réalité il pointe sur autre chose.

**grex1** · 18/08/2010, 17h26

Pourtant le gdk pixbuf c'est bien

Code :

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

pImage = gtk_image_new_from_file("image.bmp");

Et l'image s'affiche correctement et je les bien ajouter dans la fonction gdkpixbuf_get_colors_by_coordinates de cette fasson:

Code :

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

gdkpixbuf_get_colors_by_coordinates(pImage, x, y,red,green,blue);

Sa serai possible que vous me corrigiez le code?

**liberforce** · 18/08/2010, 17h32

Je te conseille de commencer par la base: faire un programme sans interface graphique. Là tu ajoutes une couche de difficulté supplémentaire. Fais plutôt une petit programme qui charge une image à un emplacement connu, avec gdk_pixbuf_new_from_file. Ensuite tu manipules le pixbuf pour modifier la couleur des pixels, et ensuite tu sauves l'image sous un autre nom.

Une fois cela réussi, tu pourras intégrer cela dans une application GTK+.

**liberforce** · 18/08/2010, 17h34

Envoyé par grex1

Pourtant le gdk pixbuf c'est bien

Code :

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

pImage = gtk_image_new_from_file("image.bmp");

Là tu crées un GtkImage, pas un GdkPixbuf. Un GtkImage c'est un widget GTK destiné à contenir une image et l'afficher. Un GdkPixbuf, c'est juste un buffer d'octets représentant les pixels...

Pour accéder au pixbuf affiché par le GtkImage, il faut utiliser gtk_image_get_pixbuf.

**grex1** · 18/08/2010, 18h13

Pour gdk_pixbuf_new_from_file. je sais pas du tout comment l'utiliser tout est expliquer en anglais.
Pour gtk_image_get_pixbuf. j'ai rajouter

Code :

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

pixbuf= gtk_image_get_pixbuf(pImage);

à mon code :

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
#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);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
      GtkWidget *pHBox;
    GtkWidget *pImage;
      GtkWidget *pixbuf;
 
 
        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);
 
 
pImage = gtk_image_new_from_file("image.bmp");
pixbuf= gtk_image_get_pixbuf(pImage);
 
  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);
 
 
guchar *red=NULL, *green=NULL, *blue=NULL;
 
 
gint x=0,y=0;
 
gdkpixbuf_get_colors_by_coordinates(pixbuf, x, y,red,green,blue);
 
 
 
 
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);
 
      /* Connexions des signaux: */
 
 
 
    /* Connexion du signal "clicked" du GtkButton */
    g_signal_connect(G_OBJECT(bouton), "clicked", G_CALLBACK(modifierpixel), (GtkWidget*) pVBox);
 
 
 
 
 
 
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
 
 
/* Fonction callback executee lors du signal "clicked" */
void modifierpixel(GtkWidget *pButton, gpointer data)
{
 
 
 
 
}
 
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 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);
 
  *red   = pixel[(x*channel)+(y*width*channel)];
  *green = pixel[(x*channel)+(y*width*channel)+1];
  *blue  = pixel[(x*channel)+(y*width*channel)+2];
 
  return TRUE;
}

Mais ses pire qu'aven j'ai un segmentation fault et mon programme ne s'ouvre plus.

**teuf13** · 19/08/2010, 00h35

Je te conseillais gdk_pixbuf_new_from_file parce que c'est très simple à utiliser, tu lui donnes juste un nom de fichier et NULL en second argument. En ce qui concerne ton gtk_image_get_pixbuf, je n'ai qu'à moitié confiance, il me semble que des fois ça renvoie NULL au lieu de renvoyer un pixbuf.

**Slookeur** · 19/08/2010, 01h31

Et voilà ... je met simplement une routine qui génère une pixmaps et sa couleur en fonction de la GdkColor désiré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
GdkPixmap * draw_pixmap (GdkColor * pixcolor)
{
  GdkPixmap * pix;
  cairo_surface_t * cst;
  cairo_t * tcst;
  cairo_t * cr_pixmap;
  int xsize = 800;
  int ysize = 600;
  int colordepth=24;
 
  pix = gdk_pixmap_new (NULL, xisze, ysize, colordepth);
  cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, xisze, ysize);
  tcst = cairo_create(cst);
/* L'image en rouge
 pixcolor -> red = 65535.0
 pixcolor ->green = 0.0
 pixcolor -> blue = 0.0 */
  cairo_set_source_rgba (tcst, pixcolor -> red/65535.0, 
                               pixcolor -> green/65535.0,
                               pixcolor -> blue/65535.0, 1.0);
  cairo_paint (tcst);
  cairo_stroke (tcst);
/* L'image en noir
   pixcolor -> red = 65535.0
  pixcolor ->green = 65535.0
  pixcolor -> blue = 65535.0
  cairo_set_source_rgba (tcst, pixcolor -> red/65535.0, 
                               pixcolor -> green/65535.0,
                               pixcolor -> blue/65535.0, 1.0);
  cairo_paint (tcst);
  cairo_stroke (tcst); */
  cairo_destroy (tcst);
  cr_pixmap = gdk_cairo_create(pix);
  cairo_set_source_surface (cr_pixmap, cst, 0, 0);
  cairo_paint(cr_pixmap);
  cairo_destroy(cr_pixmap);
  cairo_surface_destroy(cst);
  return (pix);
}

En fait je ne crois pas que tu puisses changer la couleur de la pixmap, il faut la recréer.

**teuf13** · 19/08/2010, 10h51

Hmm, on parle des GdkPixbuf ici, pas de GdkPixmap

**liberforce** · 19/08/2010, 10h57

@slookeur : ça ne va pas franchement l'avancer s'il ne sait pas quoi faire de la pixmap... Et effectivement, cairo c'est mieux (d'ailleurs les fonction de dessin GDK vont être retirées de GTK 3.0 au profit d'une API utilisant massivement cairo), mais le manuel cairo n'est disponible, comme celui de GTK, qu'en anglais...

**Slookeur** · 19/08/2010, 11h05

Désolé, j'ai lu Pixbuf et compris Pixmap ...

**grex1** · 19/08/2010, 13h48

Pour pixmap c'est la premier fois que j'en entend parlé si ses mieux que pixbuf est que ses aussi multiplatforme pourquoi pas.
Par contre j'émerai bien avoir une éxplication j'ai corriger les erreurs qu'on m'a dit et j'en suis presque toujours au même point.
En voyent juste le code des fonctions sa a été insuffisent donc j'émerai bien qu'on me montre comment fonctionne ses fonctions est dans qu'elle ordre.
Sa serai possible qu'n me donne un code complet comme je les dit au début de mon post?
Pas besoin d'un longue explication rien qu'en voyent le code je devrai apprendre par mal de chose.

**teuf13** · 19/08/2010, 14h22

Envoyé par grex1

Sa serai possible qu'n me donne un code complet comme je les dit au début de mon post?
Pas besoin d'un longue explication rien qu'en voyent le code je devrai apprendre par mal de chose.

Regarder du code déjà écrit et guider la personne pour qu'elle comprenne ce qui ne va pas, c'est plus simple et ça prend beaucoup moins de temps que d'écrire du code à partir de 0 pour donner un exemple, c'est entre autre pour ça que je privilégie les explications

Remets ton code actuel, je vais au moins essayer de le compiler... Et râler s'il y a des warnings à la compilation ou à l'exécution qui te disent pourquoi ça ne fonctionne pas

**grex1** · 19/08/2010, 16h32

Mon code actuel je l'ai déjà posté hier à 18heur13 c'est selui si :

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
#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);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
      GtkWidget *pHBox;
    GtkWidget *pImage;
      GtkWidget *pixbuf;
 
 
        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);
 
 
pImage = gtk_image_new_from_file("image.bmp");
pixbuf= gtk_image_get_pixbuf(pImage);
 
  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);
 
 
guchar *red=NULL, *green=NULL, *blue=NULL;
 
 
gint x=0,y=0;
 
gdkpixbuf_get_colors_by_coordinates(pixbuf, x, y,red,green,blue);
 
 
 
 
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);
 
      /* Connexions des signaux: */
 
 
 
    /* Connexion du signal "clicked" du GtkButton */
    g_signal_connect(G_OBJECT(bouton), "clicked", G_CALLBACK(modifierpixel), (GtkWidget*) pVBox);
 
 
 
 
 
 
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
 
 
/* Fonction callback executee lors du signal "clicked" */
void modifierpixel(GtkWidget *pButton, gpointer data)
{
 
 
 
 
}
 
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 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);
 
  *red   = pixel[(x*channel)+(y*width*channel)];
  *green = pixel[(x*channel)+(y*width*channel)+1];
  *blue  = pixel[(x*channel)+(y*width*channel)+2];
 
  return TRUE;
}

J'ai un segmentation fault dans la console depuis que j'ai ajouter:
pixel=gdk_pixbuf_get_pixels(pixbuf);

Exemple de programme qui change tous les pixels noirs d'un GdkPixbuf en rouge

GTK+ avec C & C++

Discussions similaires

Partager

Partager