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