Discussion :

[Sophie L.]

Bonjour,

Pour mon application, je dois créer une miniature d'un panel composé de plusieurs éléments graphiques afin de permettre à l'utilisateur de pouvoir l'organiser à sa guise sans modifier le panel de départ et en ayant un aperçu du rendu.
J'ai utilisé une méthode utilisant des BufferedImage mais je ne les avais jamais réellement utilisés auparavant. Je ne suis donc pas certaine de leur "bonne" utilisation.
Suite à cette implémentation, j'ai eu quelques soucis de manque de mémoire (JAVA HEAP SPACE), j'aimerais donc savoir s'il y a possibilité de s'y prendre autrement ou mieux.
Voici cette méthode :

• création d'un BufferedImage de chaque composant figurant sur le panel de départ
  

  Code :

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

  1
  2
  3
  4
  BufferedImage image = new BufferedImage(WidthImage,HeightImage,BufferedImage.TYPE_INT_ARGB);
  Graphics2D g2d = image.createGraphics();
  Component.paint(g2d);
  g2d.dispose();

• création de BufferedImage de composant non visible sur l'interface ajouté par l'utilisateur
  

  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
  protected void createImageNotVisible(JPanel ANewPanel, int Awidth, int Aheight){
  		ANewPanel.setSize(Awidth,Aheight);
  		ANewPanel.setPreferredSize(new Dimension(Awidth,Aheight));
  		ANewPanel.doLayout();
  		ANewPanel.validate();
   
  		JWindow f = new JWindow();
  		f.getContentPane().add(ANewPanel);
  		f.pack();
   
  		f.doLayout();
  		f.validate();
   
  		int lwidth = ANewPanel.getSize().width;
  		int lheight = ANewPanel.getSize().height;
   
  		if (lwidth <= 0){
  			lwidth = Awidth;
  		}
   
  		if (lheight <= 0){
  			lheight = Aheight;
  		}
   
  		BufferedImage image = new BufferedImage(lwidth, lheight, BufferedImage.TYPE_INT_ARGB);
  		Graphics2D g2d = image.createGraphics();
  		f.getContentPane().paint(g2d);
  		g2d.dispose();
  		f.dispose();
   
  		FImageDisplay = image;
  }

Si cette méthode est correcte, j'ai un 2nd point que j'ai développé qui pourrait poser un problème de mémoire. Pour que l'utilisateur puisse visualiser sur quel composant il agit, j'ai grisé l'image sur la miniature en lui appliquant un filtre de la façon suivante :

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
 
RGBImageFilter imf = new darkerFilter();
ImageProducer source = MonImageDisplay.getSource();
ImageProducer ip = new FilteredImageSource(source, imf);
java.awt.Image imageFiltree =  Toolkit.getDefaultToolkit().createImage(ip);
BufferedImage bufImage = new BufferedImage(imageFiltree.getWidth(null), imageFiltree.getHeight(null), BufferedImage.TYPE_INT_RGB);
bufImage.getGraphics().drawImage(imageFiltree, 0, 0, null);
 
/**
* Classe permettant d'apliquer un filtre foncé sur une image
* @author 
*
*/
private class darkerFilter extends RGBImageFilter {
public darkerFilter() {
	canFilterIndexColorModel = true;
}
 
public int filterRGB(int x, int y, int rgb) {
	return new Color(rgb).darker().getRGB();
}
}

L'effet visuel est réussi, cependant, je ne sais pas comment faire pour revenir à l'image de départ (ie non grisée) sans perdre la netteté à part en mémorisant cette image de départ.

J'espère que les connaisseurs de la gestion d'image ne s'arracheront pas trop les cheveux à la lecture de ce post...

Merci d'avoir lu mon problème et merci d'avance pour tous vos commentaires.

Sophie

[Sophie L.]

Bonjour,

J'ai continué à faire des essais et j'ai l'impression que ce qui me crée mon problème de mémoire serait le 2nd point du poste précédent c'est-à-dire ma manière de notifier visuellement l'élément sélectionné de ma miniature.

Voici la partie de code gérant cet aspect :

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
import java.awt.Color;
import java.awt.Toolkit;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.image.BufferedImage;
import java.awt.image.FilteredImageSource;
import java.awt.image.ImageProducer;
import java.awt.image.RGBImageFilter;
 
import javax.swing.JPanel;
import javax.swing.border.LineBorder;
 
/**
 *
 */
public class Miniature extends JPanel implements FocusListener{
 
	/**Image à afficher*/
	private BufferedImage FImageDisplay;
	/**Image de base mémorisée pendant la sélection*/
	private BufferedImage FImageDisplayTemp = null;
 
	/**************************************************************************************
     * Gestion de l'interface FocusListener
     **************************************************************************************/
 
	public void showFocusGained(){
		setBorder(new LineBorder(Color.RED));
 
		if (FImageDisplayTemp == null){
			RGBImageFilter imf = new darkerFilter();
			ImageProducer source = FImageDisplay.getSource();
			ImageProducer ip = new FilteredImageSource(source, imf);
			java.awt.Image imageFiltree =  Toolkit.getDefaultToolkit().createImage(ip);
			BufferedImage bufImage = new BufferedImage(FImageDisplay.getWidth(), FImageDisplay.getHeight(), BufferedImage.TYPE_INT_RGB);//imageFiltree.getWidth(null), imageFiltree.getHeight(null), BufferedImage.TYPE_INT_RGB);
			bufImage.getGraphics().drawImage(imageFiltree, 0, 0, null);
			FImageDisplayTemp = FImageDisplay;
			FImageDisplay = bufImage;
		}
 
	}
 
	public void focusGained(FocusEvent e) {
		showFocusGained();
 
		//Notification du panel englobant tous les composants de type Miniature que l'élément sélectionné a changé
               //notifyChangeSelectedPanel();
 
	}
 
	public void focusLost(FocusEvent e) {
		setBorder(null);
 
		if (FImageDisplayTemp != null){
			FImageDisplay = FImageDisplayTemp;
			FImageDisplayTemp = null;
		}
 
	}
 
	/**
         * Classe permettant d'apliquer un filtre foncé sur une image
         *
         */
	private class darkerFilter extends RGBImageFilter {
		public darkerFilter() {
			canFilterIndexColorModel = true;
		}
 
		public int filterRGB(int x, int y, int rgb) {
			return new Color(rgb).darker().getRGB();
		}
	}
 
 
}

Je reste persuader que je peux revenir à l'image de départ (ie non grisée) sans perdre la netteté sans mémoriser cette image de départ mais je ne sais pas comment m'y prendre.
Merci d'avance pour tous vos conseils et n'hésitez pas à me donner des tuyaux pour mon poste en globalité .

Sophie

[bouye]

Il y a un probleme general lie a la creation de miniatures qui est qu'il faut charger l'image en memoire pour la creer ce qui peut etre genant lorsqu'on manipule des images de grandes tailles.

Il ne faut pas hesiter a prevoir un suport du JAI (Java Advanced Imaging) qui permet de charger les images "par morceaux" (tile) avec la classe PlanarImage.

Parmis les autres optimisations possibles :

• Ne pas conserver toutes les miniatures en memoire mais uniquement celles qui sont actuellement affichees/visibles. Les autres peuvent etre stockees dans des fichiers temporaires JPEG ou PNG sur le disque.
• De la meme maniere pour permettre les undo/redo tu peux stocker les images precedentes sous formes de PNG (pour ne pas perdre de qualite) dans un repertoire temporaire.