Modifier l'échelle d'une image dans un buffer

Version imprimable

Bonjour,
Je n'arrive pas à utiliser ce code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/** Effectue une homothétie de l'image.
 * 
 * @param bi l'image.
 * @param scaleValue la valeur de l'homothétie.
 * @return une image réduite ou agrandie.
 * 
 */public static BufferedImage scale(BufferedImage bi, double scaleValue) {
        AffineTransform tx = new AffineTransform();
        tx.scale(scaleValue, scaleValue);
        AffineTransformOp op = new AffineTransformOp(tx,
                AffineTransformOp.TYPE_BILINEAR);
        BufferedImage biNew = new BufferedImage( (int) (bi.getWidth() * scaleValue),
                (int) (bi.getHeight() * scaleValue),
                bi.getType());
        return op.filter(bi, biNew);
 
}

dans l'exemple de David SEIGNE sur le double-buffering software

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
public class DoubleBufferingSoftware extends Frame{
   // boucle d'affichage
   RenderingThread renderingThread = new RenderingThread();
   // buffer mémoire (2eme buffer)
   Graphics buffer;
   // image mémoire correspondante au buffer
   Image image; 
   int x = 0; // coordonnée x de l'affichage du texte
 
   public DoubleBufferingSoftware(){
      //affichage
      setSize( 400, 400 );
      setVisible( true );
 
      // on démarre la bouche d'affichage
      renderingThread.start();
 
   }
   public void update(Graphics g){
      paint(g);
   }
   public void paint( Graphics g ){
     //création du buffer si il n'existe pas
     if(buffer==null){
        image = createImage(400,400);
        buffer = image.getGraphics();
      }
     //on dessine sur le buffer mémoire
      buffer.setColor( Color.white );
      buffer.fillRect( 0, 0, 400, 400 );
      buffer.setColor( Color.black );
      buffer.drawString( "affichage d'une ligne de texte", x, 200 );
      x++;
      if(x>400) x = 0;
      // finalement, le buffer mémoire est dessiné dans le buffer d'affichage
      g.drawImage(image, 0, 0, this);
   }
   class RenderingThread extends Thread {
     /**
      *  Ce thread appelle le rafraichissement de notre fenêtre 
      *  toutes les 10 milli-secondes
      */
      public void run(){
         while(true){
            try {
               repaint(); 
               sleep( 10 );
            } catch ( Exception e ) {} 
         }
      }
   }   
   public static void main(String[] args){new DoubleBufferingSoftware();}
}

pouvez-vous m'aiguiller SVP
Alain

02/08/2011, 19h26
kolodz

Bonsoir,

Je n'ai pas tenté d'utiliser votre fonction, mais elle me semble "normal" et devrai fonctionner.

Si vous pouviez nous indiquez ce que vous n'arrivez pas à faire avec cette fonction...

Par contre attention à votre code votre image est déclaré entant qu'objet de la classe Image et non de la classe BufferedImage.
(BufferedImage hérite d'Image)
cf javadoc : http://download.oracle.com/javase/6/...eredImage.html

Cordialement,
Patrick Kolodziejczyk.
03/08/2011, 18h23
alainb

Citation:

Je n'ai pas tenté d'utiliser votre fonction, mais elle me semble "normal" et devrai fonctionner.
Si vous pouviez nous indiquez ce que vous n'arrivez pas à faire avec cette fonction...

Bonjour Patrick,
Pour tout dire je suis un VRAI débutant Java. Je souhaite appeler la fonction dans le code exemple de David SEIGNE
Alain

Bonjour,
J'ai intégré la fonction dans le code et modifié quelques lignes

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
 
@SuppressWarnings("serial")
public class DoubleBufferingSoftware extends Frame {
 
	/**
         * Effectue une homothétie de l'image.
         * 
         * @param bi
         *            l'image.
         * @param scaleValue
         *            la valeur de l'homothétie.
         * @return une image réduite ou agrandie.
         * 
         */
	public static BufferedImage scale(BufferedImage bi, double scaleValue) {
		AffineTransform tx = new AffineTransform();
		tx.scale(scaleValue, scaleValue);
		AffineTransformOp op = new AffineTransformOp(tx,
				AffineTransformOp.TYPE_BILINEAR);
		BufferedImage biNew = new BufferedImage(
				(int) (bi.getWidth() * scaleValue),
				(int) (bi.getHeight() * scaleValue), bi.getType());
		return op.filter(bi, biNew);
 
	}
 
	// boucle d'affichage
	RenderingThread renderingThread = new RenderingThread();
	// buffer mémoire (2eme buffer)
	Graphics buffer;
	// image mémoire correspondante au buffer
	Image image;
	int x = 0; // coordonnée x de l'affichage du texte
 
	public DoubleBufferingSoftware() {
		// affichage
		setSize(400, 400);
		setVisible(true);
 
		// on démarre la bouche d'affichage
		renderingThread.start();
 
	}
 
	public void update(Graphics g) {
		paint(g);
	}
 
	public void paint(Graphics g) {
		// création du buffer si il n'existe pas
		if (buffer == null) {
			image = createImage(400, 400);
			buffer = image.getGraphics();
		}
		// on dessine sur le buffer mémoire
		buffer.setColor(Color.white);
		buffer.fillRect(0, 0, 400, 400);
		buffer.setColor(Color.black);
		buffer.fillRect(150, 150, 100, 100);
 
		// finalement, le buffer mémoire est dessiné dans le buffer d'affichage
		g.drawImage(image, 0, 0, this);
 
	}
 
	class RenderingThread extends Thread {
		/**
                 * Ce thread appelle le rafraichissement de notre fenêtre toutes les 10
                 * milli-secondes
                 */
		public void run() {
			while (true) {
				try {
					repaint();
					sleep(10);
				} catch (Exception e) {
				}
			}
		}
	}
 
	public static void main(String[] args) {
		new DoubleBufferingSoftware();
	}
}

Je ne comprends pas la remarque de kolodz

Citation:

attention à votre code votre image est déclaré entant qu'objet de la classe Image et non de la classe BufferedImage, (BufferedImage hérite d'Image)

Son propos est clair mais je n'arrive pas à mes fins : agrandir l'échelle du dessin avec la fonction !
Je teste sur

Code:

g.drawImage(image, 0, 0, this);

:calim2:
Alain

17/08/2011, 15h04
sinok

C'est bien d'avoir une méthode scale dans la classe, ce serait quand même vachement mieux de l'utiliser ;)
17/08/2011, 16h55
alainb

Citation:

Envoyé par sinok

C'est bien d'avoir une méthode scale dans la classe, ce serait quand même vachement mieux de l'utiliser ;)

Bonjour sinok,
effectivement ta remarque est juste, c'est l'objet de ma question. Comment passer les paramètres dans la fonction scale
Alain

Bah tu change le type de ton Image en BufferedImage dans la classe.

C'est à dire qu'il faut que tu dessines ton Image dans une BufferedImage.

Code:

1
2
3
4
5
6
7
8
9
10
image = createImage(400, 400);
//Pour de l'optimisation on crée une BufferedImage compatible avec le contexte graphique de l'OS
GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
BufferedImage bi = gc.createCompatibleImage(image.getWidth(null), image. getHeight(null), BufferedImage.TYPE_INT_ARGB);
//On dessine l'Image initiale sur la BufferedImage
Graphics g = bi.createGraphics();
g.drawImage(im);
g.dispose();
//On scale l'image
bi = scale(bi,0.8);

Citation:

Envoyé par sinok

Bah tu change le type de ton Image en BufferedImage dans la classe.
C'est à dire qu'il faut que tu dessines ton Image dans une BufferedImage.

J'ai modifié mon code avec ta proposition.

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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
 
@SuppressWarnings("serial")
public class DoubleBufferingSoftware extends Frame {
 
	/**
         * Effectue une homothétie de l'image.
         * 
         * @param bi
         *            l'image.
         * @param scaleValue
         *            la valeur de l'homothétie.
         * @return une image réduite ou agrandie.
         * 
         */
	public static BufferedImage scale(BufferedImage bi, double scaleValue) {
		AffineTransform tx = new AffineTransform();
		tx.scale(scaleValue, scaleValue);
		AffineTransformOp op = new AffineTransformOp(tx,
				AffineTransformOp.TYPE_BILINEAR);
		BufferedImage biNew = new BufferedImage(
				(int) (bi.getWidth() * scaleValue),
				(int) (bi.getHeight() * scaleValue), bi.getType());
		return op.filter(bi, biNew);
 
	}
 
	// boucle d'affichage
	RenderingThread renderingThread = new RenderingThread();
	// buffer mémoire (2eme buffer)
	Graphics buffer;
	// image mémoire correspondante au buffer
	Image image;
	int x = 0; // coordonnée x de l'affichage
 
	public DoubleBufferingSoftware() {
		// affichage
		setSize(400, 400);
		setVisible(true);
 
		// on démarre la bouche d'affichage
		renderingThread.start();
	}
 
	public void update(Graphics g) {
		paint(g);
	}
 
	public void paint() {
		// création du buffer s'il n'existe pas
		if (buffer == null) {
 
			// buffer = image.getGraphics();
 
			image = createImage(400, 400);
			// Pour l'optimisation on crée une BufferedImage compatible avec le
			// contexte graphique de l'OS
			GraphicsConfiguration gc = GraphicsEnvironment
					.getLocalGraphicsEnvironment().getDefaultScreenDevice()
					.getDefaultConfiguration();
			BufferedImage bi = gc.createCompatibleImage(image.getWidth(null),
					image.getHeight(null), BufferedImage.TYPE_INT_ARGB);
		}
 
		// on dessine sur le buffer mémoire
		buffer.setColor(Color.white);
		buffer.fillRect(0, 0, 400, 400);
		buffer.setColor(Color.black);
		buffer.fillRect(150, 150, 100, 100);
 
		BufferedImage bi = null;
		// On dessine l'Image initiale sur la BufferedImage
		Graphics g = bi.createGraphics();
		Image im = null;
 
		g.drawImage(im, 0, 0, this);
		g.dispose();
		// On scale l'image
		bi = scale(bi, 0.8);
 
	}
 
	class RenderingThread extends Thread {
		/**
                 * Ce thread appelle le rafraichissement de notre fenêtre toutes les 10
                 * milli-secondes
                 */
		public void run() {
			while (true) {
				try {
					repaint();
					sleep(10);
				} catch (Exception e) {
				}
			}
		}
	}
 
	public static void main(String[] args) {
		new DoubleBufferingSoftware();
	}
}

Le rectangle ne s'affiche toujours pas. A priori la fonction n'est pas appelée :?

Code:

1
2
3
4
5
6
7
8
9
BufferedImage bi = null;
// On dessine l'Image initiale sur la BufferedImage
Graphics g = bi.createGraphics();
Image im = null;

g.drawImage(im, 0, 0, this);
g.dispose();
// On scale l'image
bi = scale(bi, 0.8);

Tu ne vois pas quelque chose de choquant dans ce code?

17/08/2011, 20h11
alainb

Citation:

Envoyé par sinok

Tu ne vois pas quelque chose de choquant dans ce code?

Oui, avec un Null (comme moi) cela marche moins bien !
En bref je suis noyé !

l'insertion de tes lignes de code génère des messages "variables en double"
et g.drawImage(im); devrait être remplacé par g.drawImage(im, 0, 0, this);

Peux-tu me dire précisément où sont les erreurs ?
Alain