Discussion :

[Joruus]

Bonjour,

Je suis en train de faire un petit logiciel qui ouvre des fichiers CSV et qui doit dessiner des courbes en fonction des données issus du CSV.

Les fichiers CSV contiennent des nombres séparés par des virgules comme ceci :

192,256,312,
118,257,333,
178,255,324,

Ces nombres correspondent à la position de pixel noir sur des lignes horizontales, la position max étant 2048.
La position verticale correspond au numéro de ligne ceci pour avoir un fichier CSV le plus léger possible.

Je lis mon fichier avec le code ci dessous, la méthode

Code :

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

updateAddALine(intLines);

me permettant d'envoyer un tableau de int à la classe me permettant de dessiner.

Mon problême vient du fait que l'affichage de mes courbes se fait au fur et à mesure, je cherche à afficher mes courbes comme si on ouvrait une image sous paint.

Que dois je revoir ? La lecture de mes fichiers CSV ou la façon dont je dessine mes courbes ?


Classe permettant de lire le fichier CSV

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
 
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
BufferedReader    bufferReader      = new BufferedReader(inputStreamReader );
 
String ligne;
 
// on boucle tant que l'on peut lire des lignes ou loopControl soit a false
while(((ligne = bufferReader.readLine()) != null) && (loopControl == true)){	
 
   // une ligne contient plusieurs valeurs separe par le  separateur ''regex'', on recupere ces valeurs avec la methode regex
   String[]  lines    = ligne.split(",");
   // On cree un tableau de int pour recuperer les
   Integer[] intLines = new Integer[lines.length] ;
 
   int index = 0 ;				
   for(String value : lines){
 
      try{					
	intLines[index] = Integer.valueOf(value);
	index++ ;
 
   }catch(NumberFormatException e){
 
	System.out.println("erreur");
              break;
      }
   }
 
updateAddALine(intLines); // je mets à jour l'objet graphique												
}				
bufferReader.close();

Classe permettant de dessiner

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
 
 
	public void addLine(Integer[] inIntTab){
 
		if(listOfTab.equals(null))
			listOfTab = new ArrayList<Integer[]>();
 
		listOfTab.add(inIntTab) ;
 
		revalidate();
		this.repaint();
	}
 
 
	public void paintComponent(Graphics g){
 
		// largeur
		int widthJPanel  = this.getWidth() - widthLift ;	
		// hauteur
		int heightJPanel = listOfTab.size();
 
		g.setColor(new Color(1.0f, 1.0f, 1.0f)); // blanc
	    g.fillRect(0, 0, widthJPanel, heightJPanel);
 
	    if(listOfTab.size()== 0)
	    	return ;
 
	    // on doit inverser la descente du schema pour avoir l'effet "sismographe"
	    ArrayList<Integer[]> reverseList2 = new ArrayList< Integer[]>();
 
	    // on remplie la liste inverse
	    for(int i = listOfTab.size()-1; i >= 0; i--)
	    	reverseList2.add(listOfTab.get(i));
 
	    // on utilise pas d'iterator car il faut avoir la place du tableau de int, sa place correspond a sa position en y
	    for(int j = 0; j < reverseList2.size(); j++){
 
	    	if(reverseList2.get(j) != null){
 
		    	Integer[] tabInt = reverseList2.get(j);
 
		    	for(int i = 0; i < tabInt.length; i++){
 
		    		if(tabInt[i] != null){
 
		    			int posX           = tabInt[i] * widthJPanel / 2048/*/ tabInt.length*/ ;
		    			int pixelWeight = widthJPanel / 2048 /*/ tabInt.length*/ ;
		    			g.setColor(new Color(0.0f, 0.0f, 0.0f)); // noir
			    		g.drawLine(posX, j, posX + pixelWeight, j);
			    		g.setColor(new Color(0.0f, 0.0f, 0.0f)); // rouge
 
		    		}
		    	}
	    	}
	    }
    }

[joel.drigo]

Salut,

Dans ton code, tu lis une ligne dans le fichier, tu la parses, la convertis en tableau de Integer, puis l'ajoutes à une liste de tableaux de Integer (listOfTab), et tu recommences pour la ligne suivante : normal, que ça s'affiche progressivement.

Pour tout afficher d'un coup, il suffit de stocker tous tes tableaux de Integer dans une liste, puis d'ajouter cette liste complète après la fin de la boucle à listOfTab et de faire un seul repaint à ce moment.


Accessoirement, ce code n'a aucun sens :

Code :

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

1
2
if(listOfTab.equals(null))
			listOfTab = new ArrayList<Integer[]>();

Si hypothétiquement une instance pouvait être égale (au sens de equals()) à null, alors on ne pourrait pas appeler de méthode sous peine d'avoir une NullPointerException. Ce que tu voulais écrire est probablement ça :

Code :

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

1
2
if(listOfTab==null)
			listOfTab = new ArrayList<Integer[]>();

Par ailleurs, tu aurais interêt à utiliser des int[] au lieu de Integer[], pour un gain de performances et de mémoire utilisée.

[Joruus]

Merci pour ta réponse. J'ai optimisé mon code et maintenant je n'envoi les données que lorsqu'elles sont toutes parsées.

Précédement, pour le même fichier je mettais 1322 millisecondes contre 236 millisecondes désormais. J'ai essayé de supprimer les boucles inutiles au maximum.

Le code pour lire le fichier et le parser :

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
 
	InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
	BufferedReader    bufferReader      = new BufferedReader(inputStreamReader );
	String ligne;
 
	// on boucle tant que l'on peut lire des lignes ou loopControl soit a false
	while(((ligne = bufferReader.readLine()) != null) && (loopControl == true)){	
 
	              // une ligne contient plusieurs valeurs separe par le separateur ''regex'', on recupere ces valeurs avec lamethode regex
		String[]  lines    = ligne.split(regex);
		// On cree un tableau de int pour recuperer les
		Integer[] intLines = new Integer[lines.length] ;
 
		int index = 0 ;
 
		for(String value : lines){
 
			try{
				intLines[index] = Integer.valueOf(value);
				index++ ;
 
			}catch(NumberFormatException e){
 
				System.out.println("erreur");
				break;
			}
		}
 
		listOfTab.add(intLines) ;
 
		}
 
	bufferReader.close();
	updateAddAllLine(listOfTab);

Classe permettant de dessiner

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
 
public void addTab(ArrayList<Integer[]> inListOfTab/*, int inParentWidth*/){
 
	reverseList2 = new ArrayList< Integer[]>();
 
	    // on remplie la liste inverse
	    for(int i = inListOfTab.size()-1; i >= 0; i--)
	    	reverseList2.add(inListOfTab.get(i));
 
	// permet de faire apparaitre l'ascenseur
	revalidate();
	this.repaint();
}
 
 
public void paintComponent(Graphics g){
 
	// largeur
	int widthJPanel  = this.getWidth() - widthLift ;	
	// hauteur
	int heightJPanel = reverseList2.size();
 
	g.setColor(new Color(1.0f, 1.0f, 1.0f)); // blanc
	g.fillRect(0, 0, widthJPanel, heightJPanel);
 
	 if(reverseList2.size()== 0)
	    	return ;
 
	    // on utilise pas d'iterator car il faut avoir la place du tableau de 
	    // int, sa place correspond a sa position en y
	    for(int j = 0; j < reverseList2.size(); j++){
 
	    	if(reverseList2.get(j) != null){
 
		    	Integer[] tabInt = reverseList2.get(j);
 
		    	for(int i = 0; i < tabInt.length; i++){
 
		    		if(tabInt[i] != null){
 
		    			int posX        = tabInt[i] * widthJPanel / 2048/*/ tabInt.length*/ ;
		    			int pixelWeight = widthJPanel / 2048 /*/ tabInt.length*/ ;
		    			g.setColor(new Color(0.0f, 0.0f, 0.0f)); // noir
			    		g.drawLine(posX, j, posX + pixelWeight, j);
			    		g.setColor(new Color(1.0f, 0.0f, 0.0f)); // rouge
 
		    		}
		    	}
	    	}
	    	else{
	    	    System.out.println("eRRoR");
	    	}
	    }
    }

[joel.drigo]

Déjà, utilises un List<int[]> au lieu d'un List<Integer[]> (et intLines[index] = Integer.parseInt(value); au lieu de intLines[index] = Integer.valueOf(value);).

Ensuite, au lieu de créer 2 instances de classes Color à chaque itération, utilises des "constantes" (des final static) en général, et en particulier dans ton cas, Color.RED et Color.BLACK.

Enfin, dans la ligne int pixelWeight = widthJPanel / 2048 /*/ tabInt.length*/ ;, aucune des variables utilisées ne dépend d'une valeur variant à chaque itération, et, en l'occurence, ne dépend que de valeur de variables existant en dehors de la boucle : tu peux donc sortir ce calcul de la boucle. Ceci évitera de faire autant de fois cette division qu'il y a de ligne dans la liste.

Maintenant, je n'ai pas regardé à la loupe mais je n'ai pas vu de boucle inutile, qu'on pourrait retravailler ou supprimer pour améliorer les performances.

Si la lecture du fichier doit être améliorée, tu peux éventuellement lire toutes les lignes avec Files.readAllLines(...) (en consommant plus de mémoire forcément) : tu connaitrais le nombre de lignes d'avance, donc tu pourrais dimensionner d'avance la capacité de l'ArrayList (voir constructeur avec argument int), et, donc, gagner un peu d'allocation de tableaux de int (au remplissage).

[Joruus]

Merci pour ton aide j'ai optimisé mon code est la différence est là.