Bonjour,

Je suis débutant en graphisme java et j'ai besoin de dessiner des dizaines de milliers de petites lignes qui se déplacent sur l'écran pendant que je bouge mon stylet wacom, sans alourdir le processeur.

J'ai fait des essais avec Line2D.Float() dans Graphics2D ( en suivant les conseils de http://java.developpez.com/faq/gui/?...DESSIN_vitesse ), voir le programme ci-dessous, mais voila: Mon intel core duo 2 à 2,2Ghz mets 1 secondes pour exécuter le programme suivant, qui dessine 450 000 petites lignes de 16 pixels. Je me pose la question suivante : comment se fait t'il qu'il faille 305 cycles machines pour dessiner juste un seul pixel dans un buffer ??? (2,2Ghz -> 2 200 000 000 cycles par secondes / 450 000 lignes / 16 pixels = 305 cycles )

N'y a t'il pas d'autres méthodes plus rapides et directes pour dessiner des lignes en java ?
J'ai essayé BufferedImage.setRGB() mais c'est kif-kif par pixel. (ok, c'est plus rapide de dessiner chaque pixel avec BufferedImage.setRGB(), plutôt que d'utiliser Line2D.Float(), s'il y a moins de 10 pixels par ligne, et c'est plus lent s'il y en a plus.)

Merci d'avance pour quelque réponse.
Alexandre

P.S : Je précise que je suis un peu débutant (j'utilise surtout java pour faire de l'algorithmique, s'exécutant dans un environnement qui s'appelle Max/msp), et que la lecture des librairies java, c'est souvent du chinois pour moi. Le programme suivant est un programme d'exemple que j'ai modifié pour arriver à mes fins :
(Le programme s'exécute comme objet max-msp, mais pour l'exécuter ailleurs, il suffit de remplacer "..extends MaxObject.." et les lignes "JitterMatrix ... outlet(0, ... " par ce qui convient...)

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
import com.cycling74.max.*;
import com.cycling74.jitter.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.BufferedImage;
 
/**
* Creates a graph in a BufferedImage and then pops it into a
* JittterMatrix for output in Max-Msp.
* (By sending "outputDrawing" message to the max-msp "bufferedimage_test" object) 
*/
public class bufferedimage_test extends MaxObject {
 
	public bufferedimage_test(Atom[] args) {
		declareInlets(new int[]{DataTypes.ALL});
		declareOutlets(new int[]{DataTypes.ALL});
	}
 
	public void outputDrawing() {
		// the drawing code is probably very low impact, but it's still a
		// good idea to wrap it in a Thread to free up processor time.
		( new Thread() {
			public void run() {
				BufferedImage bim = bakePieGraph();
 
				JitterMatrix jim = new JitterMatrix(bim);
				outlet(0, "jit_matrix", jim.getName());
			}
		}).start();
	}
 
	public BufferedImage bakePieGraph() {
		Frame theframe = new Frame ();
		theframe.addNotify ();
		Image myImage = theframe.createImage(320,200);
 
		Graphics2D gc = (Graphics2D)myImage.getGraphics ();
		gc.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
		gc.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_SPEED);
		gc.setRenderingHint(RenderingHints.KEY_COLOR_RENDERING, RenderingHints.VALUE_COLOR_RENDER_SPEED);
		gc.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_OFF);
		gc.setRenderingHint(RenderingHints.KEY_DITHERING, RenderingHints.VALUE_DITHER_DISABLE);
 
                // c'est cette boucle-ci qui met une seconde a s'exécuter :
 
		for ( int i = 0; i<450000 ;i++) { 
			Shape ligne = new Line2D.Float( 10, 10,20,25  );
			gc.draw(ligne);
		}
		return makeBufferedImage(myImage);
	}
 
	public static BufferedImage makeBufferedImage(Image image) {
		BufferedImage bufferedImage = new BufferedImage(
				image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB);
		Graphics2D g2 = bufferedImage.createGraphics();
		g2.drawImage(image, null, null);
		return bufferedImage;
	}
}