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 : Sélectionner tout - Visualiser dans une fenêtre à part
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 : 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
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 !