Discussion :

[sly3333]

Bonjour

Je réalise un programme qui créé un nombre N de bufferedImage (Taille 500 x 500, Type INT_ARGB), composée chacune de 5000 triangles générés aléatoirement. Chacun de ces triangles possède une couleur générée aléatoirement (R aléatoire, G aléatoire, B aléatoire, et Alpha aléatoire).

Je précise que ce sont des images que je ne veut pas afficher. Je veut ensuite faire des statistiques sur chaque pixels et notamment sur les couleurs obtenues par superposition d'objet ayant une transparence différente. .

La génération d'une image prend environ 8 secondes, ce qui n'est pas du tout acceptable comme temps de traitement sachant que N peut varier de 100 à 1000.

J'ai l'impression que c'est la transparence qui ralentit et qu'a chaque fois que je fais un nouveau triangle, il recalcule pour chaque pixel, la couleur à afficher en fonction de tous les triangles précédemment tracés.

Pouvez vous me confirmer ?

Voici mon code

Main

Code :

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

1
2
3
4
5
6
7
8
 
public static void main(String[] args) {
 
	Image[] imgs = new image[100];
	for(int i =0;i<100;i++)
		imgs = (new Solution(5000, 500, 500, 3)).buildImage();
 
	}

Solution

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
 
 
public class Solution {
 
	private ArrayList<Forme> liste = new ArrayList<Forme>();
	private int maxWidth;
	private int maxHeight;
 
	public Solution(int nbForme, int maxWidth, int maxHeight, int maxPoints)
	{
		this.maxWidth = maxWidth;
		this.maxHeight = maxHeight;
 
		for(int i=0;i<nbForme;i++)
			liste.add(new Forme(maxWidth, maxHeight, maxPoints));
 
	}
 
	public BufferedImage buildImage()
	{
		GraphicsConfiguration configuration = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
		BufferedImage compatibleImage = configuration.createCompatibleImage(this.maxWidth, this.maxHeight, Transparency.TRANSLUCENT);
 
		Graphics g = compatibleImage.getGraphics();
	        for(Forme f : this.liste)
			f.paint(g);
 
		g.dispose();
 
		return compatibleImage;
	}

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
 
public class Forme {
 
	public Polygon polygon;
	public Color color;
 
	public Forme(int maxWidth, int maxHeight, int maxPoints)
	{
		Random r = new Random();
 
		// Generation de la couleur 
		this.color = new Color(r.nextInt(255), r.nextInt(255), r.nextInt(255), r.nextInt(255));
 
		// Generation du polygon
		int nbPoints = 3 + r.nextInt(maxPoints);
		this.polygon = new Polygon();
		for(int i=0;i<nbPoints;i++)
			polygon.addPoint(r.nextInt(maxWidth), r.nextInt(maxHeight));
	}
 
	public void paint(Graphics g)
	{
		g.setColor(this.color);
		g.fillPolygon(this.polygon);
	}
}

Je cherche à créer ces images de manière performante.

J'ai essayer d'utiliser l'accélération OPENGL de JAVA2D en rajoutant l'option qui va bien dans VM Arguments sous eclipse --> Cela ne change rien

Je pensai utiliser OPENGL directement pour générer l'image mais je ne sais pas s'il est possible de générer une image par ce biais et la manipuler ensuite sans l'afficher.

Sinon il y a les volatiles Image mais je ne suis pas sur que ce soit ce qu'il me faut.

Si quelqu'un peut confirmer ou si quelqu'un a d'autre piste je suis preneur.

[forthx]

Dans ton cas, pour cibler le probleme, un profiler semble interessant : ca devrai te permetre de voir ce qui prend le plus de temps en réalité plutot que de supposer.

Le random peut etre long par exemple.

Sur un core I5 avec java 7 x64 ca me prend quelques centaines de ms pour generer 1 000 000 Rectangle2D de maniere structuré. Puis moins d'une seconde pour faire le dessin (BufferedImage+affichage, la je profite de la carte 3D)

si je compare:
1 000 000 carré - ~1s
5 000 triangles, 8s
A mon avis le probleme est ailleur. Note que netbeans est livré avec des outils de profiling.