Chargement d'images -> Performances

Version imprimable

Bonjour,

Je suis confronté à un problème de performances ... J'explique le cas ...

Dans mon application, je suis ammené a travailler sur pas mal d'images, notament pour ce qui est des boutons, etc ... J'ai donc ces images en plusieures tailles, et parfois avec un effet de survol pour faire plus beau ...

Ainsi vous comprendrez que pour 1 image de base, j'en ai vite 6 (1 image * 3 tailles * 2 effets) ...

Voici comment je les charge a l'heure actuelle :

Code:

1 2 3 4 5 6 7 public ImageIcon charger_image(String fichier) { ImageIcon retour = null; try{ retour = new ImageIcon(this.getClass().getClassLoader().getResource(fichier)); }catch (Exception e){} return retour; }

J'ai voulu optimiser la chose en divisant donc mon nombre d'images par 6 ... A savoir :
-> 1 seule image en taille la plus grande
-> 1 image pour mon effet de survol, en PNG avec transparence ...

Et lors du chargement je lui donne l'image, la taille, et l'effet que je veux ... Ainsi j'ai rajouté du FLOU, du niveau de gris, etc ...

Voila ma méthode :

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 public ImageIcon sp_charger_image(String image,int taille, int effet) { BufferedImage img = new BufferedImage(taille,taille,BufferedImage.TYPE_INT_ARGB); try { ImageIcon img_ico = sp_charger_image( sp_image ); Graphics2D g2d = img.createGraphics(); g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); if(img_ico.getIconWidth() != taille) { Double rapport = new Double(taille) / new Double(img_ico.getIconWidth()); g2d.scale( rapport, rapport ); } g2d.drawImage( img_ico.getImage(), 0, 0, null ); switch (effet) { case ROLLOVER: g2d.drawImage( sp_charger_image( "RollOver.png" ).getImage(), 0, 0, null ); break; case GRIS: img = new ColorConvertOp( ColorSpace.getInstance(ColorSpace.CS_GRAY), null).filter(img,null); break; case LOU: float[] flou = { 0.1f, 0.1f, 0.1f, 0.1f, 0.2f, 0.1f, 0.1f, 0.1f, 0.1f }; img = new ConvolveOp(new Kernel(3,3,flou )).filter(img, null); break; case CLAIR: float[] clair = { 0f, 0f, 0f, 0f, 1.2f, 0f, 0f, 0f, 0f }; img = new ConvolveOp(new Kernel(3,3,clair )).filter(img, null); break; case SOMBRE: float[] sombre = { 0f, 0f, 0f, 0f, 0.8f, 0f, 0f, 0f, 0f }; img = new ConvolveOp(new Kernel(3,3,sombre )).filter(img, null); break; default: break; } g2d.dispose(); }catch(Exception e) {e.printStackTrace();} return new ImageIcon(img); }

Mais apres quelques tests de performance, ma seconde méthode est moins éfficace ...

Est-il possible de l'améliorer afin qu'elle soit plus éfficace ??? Si oui comment ?

Je pensait peut être charger les images 1 fois, puis les mettre dans une hashtable et ne pas les recharger completement à la seconde utilisation, mais juste les prendre dans la hashtable ... Ca serait mieux ?

Merci à vous ...

Des que je peux je met a dispo une archive qui fonctionnera avec code + images pour tester !

MErci à vous !!!

PS : En pièce jointe un ZIP qui peut être renommé en JAR ! Et qui contient les sources !

05/06/2007, 12h58
gifffftane

Je ne peux pas te répondre de façon précise, juste te donner une piste : regarde la page de Chris Campbell, qui donne plein de conseils sur les effets d'image, particulièrement The Perils of Image.getScaledInstance(), où il fait des comparatifs de vitesse entre différentes solutions.
05/06/2007, 23h05
Sanguko

Il est effectivement normal que ca prenne plus de temps dans le cas ou tu construis tes images, mais la mesure n'est pas tres representative.

Dans le premier cas, les images seront chargées une seule fois. Tu crees plusieurs ImageIcon, mais elles vont referencer les memes images. En gros tu ne construis que les 6 images de bases.

Dans le deuxieme cas, tu recrees une image a chaque appel (et evidemment un ImageIcon). En bref tu crees 48x60 images.

Il faut comme tu l'as suggeré utiliser une Hashtable pour stocker les images déjà produites.

Qqs autres petites remarques :
- pour la mesure du temps pour les perfs, utilises plutot System.currentTimeMillis()
- pour le chargement d'un image, regardes javax.imageio.ImageIO.read()
- pour calculer le facteur d'echelle, ecris plutot double factor = (double) taille/ (double) image.getWith(), au lieu de passer par des objets Double.

1 pièce(s) jointe(s)

Ok, merci beaucoup ...

Après des tests, modifs, etc ...

J'ai du mieux, mais pas encore du TOP ...

J'ai réussi, grâce a
--> mettre en BILINEAR au lieu de BICUBIC l'interpolation
--> faire une HashMap avec les imagesIcon utilisées pour pas les charegr plusieures fois

D'avoir un gain de performances d'environs 25% ...

Mais ce gain est pour les 2 méthodes ... Ainsi la méthode 2, donc celle qui charge TOUTES les images reste plus rapide et je ne comprends pas !!!

Methode 1 : environs 1000 ms de durée d'éxécution et 38Mo en mémoire
Methode 2 : environs 400 ms de durée d'éxécution et 26Mo en mémoire

Je ne comprends PAS !!! Ca devrait être l'inverse !!!

J'ai essayé le ImageIO.read() ... en remplacant

Code:

1 2 3 4 5 6 7 8 9 10 11 12 public ImageIcon charger_image(String nomfic) { ImageIcon retour = list_img.get( nomfic ); if(retour == null) { try { retour = new ImageIcon( this.getClass().getClassLoader().getResource( "img/" + nomfic ) ); list_img.put( nomfic, retour ); }catch (Exception e) { e.printStackTrace(); } } return retour; }

par

Code:

1 2 3 4 5 6 7 8 9 10 11 12 public BufferedImage charger_buffimage(String nomfic) { BufferedImage retour = list_buffimg.get( nomfic ); if(retour == null) { try { retour = ImageIO.read( new File("img/"+nomfic) ); list_buffimg.put( nomfic, retour ); }catch (Exception e) { e.printStackTrace(); } } return retour; }

Mais c'est encore pire coté performances ...

Je dois passer à coté d'un truc, mais lequel ?

Je redonne les sources modifiées au cas ou quelqu'un puisse aider ^^

06/06/2007, 12h35
Sanguko
Il faut comprendre que lorsque tu fais:
Code:

1 2 3 ImageIcon icon1 = new ImageIcon("image.png"); ImageIcon icon2 = new ImageIcon("image.png");
L'image "image.png" n'est decompressée qu'une seule fois. En fait swing (ou a mon avis awt) conserve dans une table la liste des images.
Donc il faut un peu de temps pour decompresser l'image lors de la creation de icon1, mais rien (ou presque) pour la creaiton de icon2.
C'est ce qui se passe dans ta methode 2. Il n'y a en fait que 6 decompressions, et donc 6 images differentes. Tout le reste, c'est de la simple creation d'objet (des ImageIcon), qui ont une reference vers ces images.

Dans la methode 1, tu crees des BufferedImage a chaque fois. Forcement, ca coute un peu de temps. Et tu fais les transformations systematiquement.
En fait, ce qu'il faut que tu utilises comme clé dans ta Hashtable, c'est une combinaison entre le nom de l'image d'origne, la taille, et l'effet.
Quelque chose du genre

Code:

String key = filename+"_"+taille+"_"+effet;

L'idee, c'est que tu ne feras qu'une seule fois la transformation, ce qui est alors comparable a ce qui est fait dans la methode 2.

Yesssssssssssssssss

TROP BIEN JOUE !!!!

MErci ca roule bien maintenant ... Même ressources mémoire et aussi même temps d'exécution ^^

YOUPIIIIIIIIIIIIIIIIIIIIII

Encore quelques conseils SVP :

Est-il possible d'optimiser mon code, peut êtres petites choses que je vois pas, cette méthode sera peut être la plus utilisée de ma librairie donc faut qu'elle soit nickel ! lol

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
public ImageIcon charger_image(String nomfic) {
    ImageIcon retour = list_img.get( nomfic );
    if(retour == null) {
      try {
        retour = new ImageIcon( this.getClass().getClassLoader().getResource( "img/" + nomfic ) );
        list_img.put( nomfic, retour );
      }catch (Exception e) {
        e.printStackTrace();
      }
    } 
    return retour;
  }
 
  public ImageIcon charger_image(String image, int taille, int effet) {
    String w_key = taille + "_" + SP_EFFETS[effet] + "_" + image;
    BufferedImage img = list_buffimg.get( w_key );
 
    if(img == null) {
 
      img = new BufferedImage( taille, taille, BufferedImage.TYPE_INT_ARGB );
      ImageIcon img_ico = null;
      Graphics2D g2d    = null;
 
      try {
        img_ico = charger_image( image );
        g2d = img.createGraphics();
 
        g2d.setRenderingHint( RenderingHints.KEY_INTERPOLATION,
                              RenderingHints.VALUE_INTERPOLATION_BILINEAR );
 
        if (img_ico.getIconWidth() != taille) {
          Double w_rapport = (double) taille / (double) img_ico.getIconWidth();
          g2d.scale( w_rapport, w_rapport ); 
        }
 
        g2d.drawImage( img_ico.getImage(), 0, 0, null );
 
        switch (effet) {
          case SP_ROLLOVER:
            g2d.drawImage( charger_image( "32_RO2.png" ).getImage(), 0, 0, null );
            break;
          case SP_GRIS:
            img = new ColorConvertOp( ColorSpace.getInstance( ColorSpace.CS_GRAY ), null ).filter( img,null );
            break;
          case SP_FLOU:
            float[] flou = { 0.1f, 0.1f, 0.1f, 0.1f, 0.2f, 0.1f, 0.1f, 0.1f, 0.1f };
            img = new ConvolveOp( new Kernel( 3, 3, flou ) ).filter( img, null );
            break;
          case SP_CLAIR:
            float[] clair = { 0f, 0f, 0f, 0f, 1.2f, 0f, 0f, 0f, 0f };
            img = new ConvolveOp( new Kernel( 3, 3, clair ) ).filter( img, null );
            break;
          case SP_SOMBRE:
            float[] sombre = { 0f, 0f, 0f, 0f, 0.8f, 0f, 0f, 0f, 0f };
            img = new ConvolveOp( new Kernel( 3, 3, sombre ) ).filter( img, null );
            break;
          default:
            break;
        }
        list_buffimg.put( w_key, img );
        g2d.dispose();
      } catch (Exception e) {
        e.printStackTrace();
      } finally {
        g2d     = null;
        img_ico = null;
      }
    }
    return new ImageIcon( img );
  }

Et la je suis pas sur de mon coup ... TOUTES les ressources sont bien libèrées quand je fait ca ?

06/06/2007, 15h40
Sanguko
Citation:

Envoyé par JamesP

Est-il possible d'optimiser mon code, peut êtres petites choses que je vois pas, cette méthode sera peut être la plus utilisée de ma librairie donc faut qu'elle soit nickel ! lol

Code:

img_ico = charger_image( image );

Avoir une table pour les images de base est sans doute inutile. Vu que tu as déjà une table pour les images avec effet et taille.

Utiliser ImageIcon pour charger une image, ca me surprend un peu. A vrai dire, j'aurais utilisé soit ImageIO.read(), soit java.awt.Toolkit.createImage() et un MediaTracker.

Code:

Double w_rapport = (double) taille / (double) img_ico.getIconWidth();

a remplacer par

Code:

double w_rapport = (double) taille / (double) img_ico.getIconWidth();
Code:

1 2 3 4 5 finally { g2d = null; img_ico = null; }
Tel que ca ne sert pas a grand chose. Tu peux ecrire quelque chose du genre
Code:

1 2 3 4 5 finally { if (g2d!=null) g2d.dispose(); }
Pour les ressources, je ne pense pas qu'il y ait de probleme.
06/06/2007, 15h54
JamesP

Merci ...

Alors pour l'objet "Double" j'avais pas vu, c'est cool

pour libèrer les ressources c'est OK j'ai changé ...
Mais dans le cas ou img est une BufferedImage et g2d le Graphics de img, Si je libere img, l'autre est libèré aussi ? Faut il libèrer g2d PUIS img ?

Enfin pour le chargement des images, j'ai modifié ca avec ImageIO.read() ... Ca roule et c'est mieux ^^

J'ai aussi rajouté une HashTable pour les images de base afin quelles aussi ne soit chargées qu'une seule fois ...

Exemple :
-> Si je fait une image en 32 grisée et une image en 24 flou a partir de la même image de base, pour le créations il recreait l'image basique avant dela transformer ...

Je crois que c'est pas mal la ...

MERCI A VOUS !!!

Bonne fin de journée ^^
06/06/2007, 16h16
Sanguko

Citation:

Envoyé par JamesP

Mais dans le cas ou img est une BufferedImage et g2d le Graphics de img, Si je libere img, l'autre est libèré aussi ? Faut il libèrer g2d PUIS img ?

S'il n'y a plus de reference, les objets et ressources associés seront liberees par le garbagge collector. Donc a priori, tout est ok.
06/06/2007, 16h24
JamesP

Oki ca roule donc ... Merci beaucoup ... Maintenant, avec les 2 methode j'arrive a des résultats de performances et de mémoire quasi-identiques ...

Ce qui me parrait quand même louche car pour moi la méthode 1 devrait être BEAUCOUP plus rapide que la 2, et aussi beaucoup plus légère non ?