Afficher deux images côte à côte

**FirePrawn** · 10/10/2011, 15h43

Et rebonjour

Voici mon code complet cette fois-ci :

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
 
void OnQuitter(GtkWidget* widget, gpointer data);
void OnAbout(GtkWidget* widget, gpointer data);
void open_image();
void save_image();
void binarize_image();
void recuperer_chemin (GtkWidget *bouton, GtkWidget *file_selection);
 
GtkWidget *pVBox;
GtkWidget *pWindow;
GtkWidget *dialog;
GtkWidget *pImage;
GdkPixbuf *pixbuf;
char *filename;
 
int main(int argc, char **argv)
{
    /* Declaration des widgets */
	GtkWidget *pMenuBar;
	GtkWidget *pMenu;
	GtkWidget *pMenuItem;
 
    /* Initialisation de GTK+ */
    gtk_init(&argc,&argv);
 
    /* Creation de la fenetre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /* Definition de la position */
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    /* Definition de la taille de la fenetre */
	gtk_window_set_default_size(GTK_WINDOW(pWindow), 1200, 600);
	/* Titre de la fenetre */
	gtk_window_set_title(GTK_WINDOW(pWindow), "OrcaOM");
    /* Connexion du signal "destroy" */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Creation de la GtkVBox */
	pVBox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
	/**** Creation du menu ****/
 
	/* ETAPE 1 */
	pMenuBar = gtk_menu_bar_new();
	/** Premier sous-menu **/
	/* ETAPE 2 */
	pMenu = gtk_menu_new();
	/* ETAPE 3 */
	pMenuItem = gtk_menu_item_new_with_label("Ouvrir");
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(open_image), (GtkWidget*) pWindow);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
 
	pMenuItem = gtk_menu_item_new_with_label("Enregistrer");
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(save_image), (GtkWidget*) pWindow);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
 
	pMenuItem = gtk_menu_item_new_with_label("Binariser");
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(binarize_image), (GtkWidget*) pWindow);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
 
	pMenuItem = gtk_menu_item_new_with_label("Fermer");
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
 
	pMenuItem = gtk_menu_item_new_with_label("Quitter");
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnQuitter), (GtkWidget*) pWindow);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
	/* ETAPE 4 */
	pMenuItem = gtk_menu_item_new_with_label("Fichier");
	/* ETAPE 5 */
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
	/* ETAPE 6 */
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
 
	/** Second sous-menu **/
	/* ETAPE 2 */
	pMenu = gtk_menu_new();
	/* ETAPE 3 */
	pMenuItem = gtk_menu_item_new_with_label("A propos de...");
	g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnAbout), (GtkWidget*) pWindow);
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
	/* ETAPE 4 */
	pMenuItem = gtk_menu_item_new_with_label("?");
	/* ETAPE 5 */
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
	/* ETAPE 6 */
	gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
 
	/* Ajout du menu a la fenetre */
	gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0);
 
	/*Cration d'une image vide */
	pImage = gtk_image_new();
 
	gtk_widget_show_all(pWindow);
 
	gtk_main();
 
	return EXIT_SUCCESS;
}
 
void OnQuitter(GtkWidget* widget, gpointer data)
{
	GtkWidget *pQuestion;
 
	pQuestion = gtk_message_dialog_new(GTK_WINDOW(data),
		GTK_DIALOG_MODAL,
		GTK_MESSAGE_QUESTION,
		GTK_BUTTONS_YES_NO,
		"Voulez vous vraiment\n"
		"quitter le programme?");
 
	switch(gtk_dialog_run(GTK_DIALOG(pQuestion)))
	{
		case GTK_RESPONSE_YES:
			gtk_main_quit();
			break;
		case GTK_RESPONSE_NONE:
		case GTK_RESPONSE_NO:
			gtk_widget_destroy(pQuestion);
			break;
	}
}
 
void OnAbout(GtkWidget* widget, gpointer data)
{
	GtkWidget *pAbout;
 
	pAbout = gtk_message_dialog_new (GTK_WINDOW(data),
		GTK_DIALOG_MODAL,
		GTK_MESSAGE_INFO,
		GTK_BUTTONS_OK,
		"xxxx \n"
		"http:");
 
	gtk_dialog_run(GTK_DIALOG(pAbout));
 
	gtk_widget_destroy(pAbout);
}
 
void open_image()
{
 
	GError *error = NULL;
 
	dialog = gtk_file_chooser_dialog_new ("Open File",
					      GTK_WINDOW(pWindow),
					      GTK_FILE_CHOOSER_ACTION_OPEN,
					      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
					      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
					      NULL);
	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
	  {
	    filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
	    	/* Chargement d'une image a partir d'un fichier */
 
	    	pixbuf = gdk_pixbuf_new_from_file(filename, &error);
	    	if(!error)
	    	{
	    		GdkPixbuf *pixbuf_mini = NULL;
	    		int w = gdk_pixbuf_get_width(pixbuf);
	    		int h = gdk_pixbuf_get_height(pixbuf);
 
	    		int width, height;
	    		gtk_window_get_default_size (GTK_WINDOW(pWindow), &width, &height);
	    		double W = width * 0.7;
	    		double H = height;
 
	    		double coeff = 1;
 
	    		if (w > h) {
	    		coeff = W / w;
	    		}
	    		else {
	    		coeff = H / h;
	    		}
 
	    		W = w * coeff;
	    		H = h * coeff;
 
	    		pixbuf_mini = gdk_pixbuf_scale_simple(pixbuf, W, H, GDK_INTERP_NEAREST);
	    		gtk_image_set_from_pixbuf(GTK_IMAGE(pImage), pixbuf_mini);
	    		gtk_box_pack_start(GTK_BOX(pVBox), pImage, FALSE, FALSE, 5);
	    		gtk_widget_show (GTK_WIDGET (pImage));
	    	}
	    	else
	    	{
	    		g_critical(error->message);
	    	}
	    //open_file (filename);
	    g_free (filename);
	  }
	gtk_widget_destroy (dialog);
}
 
void binarize_image()
{
	Image *img = ImageFile::loadJpg(filename)->getImage(OCR_GRAYSCALE);
	double thresh = 0.5;
	Image* result = Binarization::computeBinarization(img, thresh);
	ImageFile::savePng(result,"OcrGui/images/");
}

Ce que j'aimerai pouvoir faire : après ma binarisation d'image, pouvoir l'afficher à côté de l'image d'origine.
Mais je ne trouve pas de méthode pour dimensionner une Vbox et donc pouvoir en mettre une deuxième à côté de la première

Une idée ? Je sais que vous avez déjà la solution

**liberforce** · 10/10/2011, 16h46

Tu veux juste deux GtkImage côte à côte, non ? Alors gtk_box_pack_start (ou pack_end) suffit pour les mettre dans ta vbox, côte à côte.

Je te conseille aussi de regarder du côté de Glade et GtkBuilder, parce que créer une interface en C pour des cas aussi simples, ça n'a d'intérêt qu'en termes pédagogiques...

**FirePrawn** · 10/10/2011, 16h53

Le but final est plus complexe rassure toi

J'ai tout un tas d'algorithme à appliquer sur mon image, et à terme il me faudra une boite de dialogue avec des paramètres modifiables pour chaque algo, et le must du must, que l'image soit modifiée en temps réel.

Dans le même genre que ce fait imageJ ( programme Java ).

**FirePrawn** · 10/10/2011, 17h02

Avec ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void binarize_image()
{
	Image *img = ImageFile::loadJpg(filename)->getImage(OCR_GRAYSCALE);
	double thresh = 0.5;
	Image* result = Binarization::computeBinarization(img, thresh);
	ImageFile::savePng(result,"images/result2.png");
	gtk_image_set_from_file(GTK_IMAGE(pImage2), "images/result2.png");
	gtk_box_pack_start(GTK_BOX(pVBox), pImage2, FALSE, FALSE, 5);
	gtk_widget_show (GTK_WIDGET (pImage2));
 
}

L'image s'affiche en dessous de la première

**liberforce** · 10/10/2011, 18h15

Envoyé par FirePrawn

Le but final est plus complexe rassure toi

J'ai tout un tas d'algorithme à appliquer sur mon image, et à terme il me faudra une boite de dialogue avec des paramètres modifiables pour chaque algo, et le must du must, que l'image soit modifiée en temps réel.

Dans le même genre que ce fait imageJ ( programme Java ).

Je connais bien, j'ai déjà utilisé ImageJ, j'ai fait du traitement d'image avec gtk-pixbuf pendant 3 ans sur un projet de recherche en environnement industriel... N'empêche que ça reste une bête interface graphique, et que la construire à la main n'a aucun intérêt. Le seul intérêt de créer l'interface à la main c'est quand il y a beaucoup de contrôles dynamiques (contrôles qui vont être ajoutés/retirés dynamiquement à l'interface selon une action de l'utilisateur).

La complexité vient de tes algos, pas de ton interface graphique, qui reste basique.

**liberforce** · 10/10/2011, 18h20

Envoyé par FirePrawn

Avec ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void binarize_image()
{
	Image *img = ImageFile::loadJpg(filename)->getImage(OCR_GRAYSCALE);
	double thresh = 0.5;
	Image* result = Binarization::computeBinarization(img, thresh);
	ImageFile::savePng(result,"images/result2.png");
	gtk_image_set_from_file(GTK_IMAGE(pImage2), "images/result2.png");
	gtk_box_pack_start(GTK_BOX(pVBox), pImage2, FALSE, FALSE, 5);
	gtk_widget_show (GTK_WIDGET (pImage2));
 
}

L'image s'affiche en dessous de la première

Sincèrement, prends un minimum de temps pour lire la doc et les tutoriels disponibles... Parce que tu poses des questions vraiment très basiques...

http://gtk.developpez.com/cours/gtk2/Gtk.Les.box.php

les GtkHBox qui permettent de disposer les widgets horizontalement ;
les GtkVBox pour les disposer verticalement.

Avant de courir, il faut apprendre à marcher...

**FirePrawn** · 11/10/2011, 09h37

J'ai tendance à utiliser le forum comme le chat lorsque je pose des questions, désolé !
De plus, je ne fais que suivre ce qu'on me demande. On m'a demandé de créer une interface en utilisant gtk, je le fais...
C'est très spécifique, en prenant quelque chose de "tout fait", les chances de pouvoir en faire ce qu'on veut sont bien plus minces...

J'ai bien vu la HBox

mes images sont bien côte à côte, mais mon menu se décale en dessous dès que j'affiche une image.

Le menu est dans la VBox, les images dans la HBox qui est contenu dans le VBox.

**liberforce** · 11/10/2011, 12h54

Envoyé par FirePrawn

De plus, je ne fais que suivre ce qu'on me demande. On m'a demandé de créer une interface en utilisant gtk, je le fais...
C'est très spécifique, en prenant quelque chose de "tout fait", les chances de pouvoir en faire ce qu'on veut sont bien plus minces...

Je crois surtout que tu n'as pas compris à quoi servait Glade.

Envoyé par FirePrawn

J'ai bien vu la HBox

mes images sont bien côte à côte, mais mon menu se décale en dessous dès que j'affiche une image.

Le menu est dans la VBox, les images dans la HBox qui est contenu dans le VBox.

Ton problème doit se situer au niveau des appels à
Lis la doc de gtk_box_pack_start ou gtk_box_pack_end.

**FirePrawn** · 11/10/2011, 12h58

Sisi j'ai bien compris, mais comme tu l'as dit, le but est aussi pédagogique ( montée en compétence en C++ ).
Donc je dois tout faire from scratch

Problème résolu, finalement j'affiche mes images dans de nouvelles fenêtres ( façon imageJ ).
Maintenant j'dois avoir des soucis de libération de mémoire/pointeurs, parce que je peux pas en afficher plusieurs avec la même fonction ; je fouille

**FirePrawn** · 11/10/2011, 14h10

Voila l'erreur qui ressort :

Gtk-WARNING **: Attempting to add a widget with type GtkImage to a container of type GtkWindow, but the widget is already inside a container of type GtkWindow, the GTK+ FAQ at http://library.gnome.org/devel/gtk-faq/stable/ explains how to reparent a widget.

Avec ce code pour afficher une image dans une nouvelle fenêtre :

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
void open_image()
{
	GError *error = NULL;
	GtkWidget *imageWindow;
 
	dialog = gtk_file_chooser_dialog_new ("Open File",
					      GTK_WINDOW(mainWindow),
					      GTK_FILE_CHOOSER_ACTION_OPEN,
					      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
					      GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
					      NULL);
	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
	  {
	    if(filename != NULL)
	    {
	    	g_free (filename);
	    }
	    	/* Creation de la fentre */
	        imageWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	        cout << imageWindow << endl;
	        /* Definition de la position */
	        gtk_window_set_position(GTK_WINDOW(imageWindow), GTK_WIN_POS_CENTER);
	        /* Definition de la taille de la fenetre */
	    	gtk_window_set_default_size(GTK_WINDOW(imageWindow), 500, 600);
	    	/* Titre de la fenetre */
	    	gtk_window_set_title(GTK_WINDOW(imageWindow), "XXXXX");
	        /* Connexion du signal "destroy" */
	        g_signal_connect(G_OBJECT(imageWindow), "destroy", G_CALLBACK(gtk_widget_destroy), NULL);
 
	    	filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
	    	/* Chargement d'une image a partir d'un fichier */
 
	    	pixbuf = gdk_pixbuf_new_from_file(filename, &error);
	    	if(!error)
	    	{
	    		GdkPixbuf *pixbuf_mini = NULL;
	    		int w = gdk_pixbuf_get_width(pixbuf);
	    		int h = gdk_pixbuf_get_height(pixbuf);
 
	    		int width, height;
	    		gtk_window_get_default_size (GTK_WINDOW(imageWindow), &width, &height);
	    		double W = width * 0.7;
	    		double H = height;
 
	    		double coeff = 1;
 
	    		if (w > h) {
	    		coeff = W / w;
	    		}
	    		else {
	    		coeff = H / h;
	    		}
 
	    		W = w * coeff;
	    		H = h * coeff;
 
	    		pixbuf_mini = gdk_pixbuf_scale_simple(pixbuf, W, H, GDK_INTERP_NEAREST);
	    		gtk_image_set_from_pixbuf(GTK_IMAGE(pImage), pixbuf_mini);
	    		gtk_container_add(GTK_CONTAINER(imageWindow), pImage);
	    		gtk_widget_show_all (imageWindow);
	    	}
	    	else
	    	{
	    		g_critical(error->message);
	    	}
	  }
	gtk_widget_destroy (dialog);
}

Avec le cout, il apparait que ma deuxieme fenêtre a la même adresse mémoire que la première ; donc que le destroy ne destroy pas finalement

**liberforce** · 11/10/2011, 14h43

Ton problème c'est la ligne 59, tu ajoutes un GtkImage dans un GtkWindow, mais tu as apparemment déjà ajouté ce GtkImage avant quelque part. Un widget ne peut avoir qu'un seul parent, tu ne peux pas le mettre successivement dans 2 conteneurs.

**FirePrawn** · 11/10/2011, 14h50

C'est ce que j'avais cru comprendre, pourtant il n'est ajouté nul part ailleurs

Je n'ai même pas de GtkHBox de déclarée

Est-ce que ce ne serait pas parce que lorsque je reclique sur "Ouvrir" et donc que j'exécute de nouveau cette fonction, les variables ont le même nom ? Ne faudrait-il pas libérer tous les pointeurs avant de les réutiliser ?

**FirePrawn** · 11/10/2011, 15h15

Problème résolu, j'ai mis ma déclaration et instanciation de *pImage dans ma fonction plutôt qu'en globale, et ça fonctionne.

Afficher deux images côte à côte

GTK+ avec C & C++

Discussions similaires

Partager

Partager