Redimension image a la taille de la fenetre.

Version imprimable

Salut à tous,
Après quelques heures a cherché comment redimensionner une image par rapport a la taille de ma fenêtre,je suis arrivé à ce code.
Je le partage donc avec vous pour être évalué et pour servir aux d'autres :D ... A++

Code:

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
#include <gtk/gtk.h>
#include <gdk/gdk.h>
#include <stdlib.h>
#include <stdio.h>
#include <glib.h>
 
void frame_callback(GtkWindow *window,GdkEvent *event, gpointer data);
void OnDestroy(GtkWidget* window, gpointer pData);
int hauteur=NULL,largeur=NULL;
 
GtkImage *image=NULL;
 
int main(int argc, char **argv)
{
  GtkWidget *window=NULL;
  GdkPixbuf *pixbuf=NULL;
 
  gtk_init(&argc, &argv);
 
  window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_widget_set_usize(GTK_WIDGET(window),960,509);
  pixbuf=gdk_pixbuf_new_from_file_at_size("decorTapis.jpg",960,509,NULL);
  image = gtk_image_new_from_pixbuf (pixbuf);
/*Signal connecter aux mouvements ou agrandissement de la fenetre a la fonction frame_callback*/
  g_signal_connect(G_OBJECT(window), "configure-event",G_CALLBACK(frame_callback),G_OBJECT(image));
 
  gtk_container_add (GTK_CONTAINER (window), image);
 
 
    gtk_widget_show_all (window);
    gtk_main ();
 
  return 0;
}
void frame_callback(GtkWindow *window,GdkEvent *event, gpointer data)
{
   /*Recuperation de la taille de la fenetre et mis dans les variable global hauteur et largeur*/
   gtk_window_get_size(GTK_WINDOW (window),&hauteur,&largeur);
    /*declaration d'un pixbuf avec le meme fichier image et mis a la nouvelle taille de la fenetre*/
   GdkPixbuf *pixbuf_mini=gdk_pixbuf_new_from_file_at_scale("decorTapis.jpg",hauteur,largeur,0,NULL);
 
    /*remplacement de l'image d'origine par la nouvelle cree*/
   gtk_image_set_from_pixbuf(GTK_IMAGE(image),pixbuf_mini);
   /*mise a jour de la fenetre*/
   gtk_widget_reset_rc_styles(GTK_WIDGET(window));
}
 
void OnDestroy(GtkWidget* window, gpointer pData)
{
gtk_main_quit();
}

19/07/2014, 10h20
gerald3d

Bonjour.

Tout d'abord penses à encadrer ton code source de balises CODE. (le # dans les icônes au dessus de l'espace pour écrire ton message). Ca présente mieux et permet surtout aux lecteurs que nous sommes d'y voir plus clair ;).

Ensuite tu génères un GdkPixbuf pour re-dimensionner l'image. Il faut penser une fois utilisé à le désallouer avec g_object_unref();. Sinon ton application va devenir vorace en utilisant mémoire.

Enfin, tu peux améliorer ton code en évitant de charger l'image originale à chaque fois depuis le disque dur. Initialises un GdkPixbuf que tu vas conserver tout le temps d'exécution de ton application. Et c'est à partir de celui-ci que tu feras ta modification.

Tout ceci ne sont bien entendu que des suggestions. Rien n'est inscrit dans le marbre ;).

J'avais trouvé sur stack overflow le calcul mathématique:

Code objectice-c :wow: qui prend en entrée une image picture (on prend juste sa largeur et sa longueur), une image finale resized_picture et la taille de la fenêtre dans laquelle on veut que notre image rentre dedans (max_picture_width, max_picture_height).

Code:

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
+ (void) resize_picture:(UIImage*) picture save_in:(UIImage**) resized_picture with_width:(float) max_picture_width and_height:(float) max_picture_height {
	if (picture == nil) { return; }
 
	RELEASE( (*resized_picture) );
 
	float new_width = 0.0f, new_height = 0.0f;
	float width  = (picture.size.width  * picture.scale); // iOS: picture.scale == 2 -> retina, default 1
	float height = (picture.size.height * picture.scale); // iOS: picture.scale == 2 -> retina, default 1
 
	float h_scale = 0.0f, w_scale = 0.0f;
 
	float max_width  = (float) (max_picture_width  * 0.8f); // 0.8f, to create margins
	float max_height = (float) (max_picture_height * 0.8f); // 0.8f, to create margins
 
	if ((width < max_width) && (height < max_height)) {
		if (width > height) {
			new_width = max_width;
			h_scale = (new_width / width);
			new_height = (height * h_scale);
		} else {
			new_height = max_height;
			w_scale = (new_height / height);
			new_width = (width * w_scale);
		}
	} else {
		w_scale = (float) (max_width  / width);
		h_scale = (float) (max_height / height);
 
		if (h_scale < w_scale) {
			new_width  = (h_scale * width);
			new_height = (h_scale * height);
		} else {
			new_width  = (w_scale * width);
			new_height = (w_scale * height);
		}
	}
 
// Create new picture with dimensions (new_width, new_height)
}