Discussion :

[joel.drigo]

Remontres moi tout le code...

[joel.drigo]

Il y a une erreur dans tracerHistogramme : tu ne traces pas la dernière valeur du tableau. Il faut faire for(int i=0; i<couleur.length; i++), comme ça, pas d'erreur possible sur la borne max.

Sinon, c'est quoi ce random à la noix pour déterminer h ? Et la formule sur le x ? Tu traces une ligne en (i,0)-(i,couleur[i]) : ce serait quand même mieux si le max était affiché aux alentours de cette ligne, au lieu de l'afficher n'importe ou (surtout qu'avec ton 300 en borne du random, tu auras la possibilité que le y soit en dehors de l'image, donc invisible !).

[YOUHANA]

Oui enfaite j'avais remarquer ça et j'ai corriger, mnt j'essaye d'afficher la position du max et du coup le i est toujours bizzarement = à 0

[joel.drigo]

Cela doit être tes images de test, c'est tout.

Essaye avec celle-là par exemple :



Tu verras que tu obtiendras :

rouge :
Le max = 10000
i 237
vert :
Le max = 10000
i 28
bleu :
Le max = 10000
i 36

[YOUHANA]

Cela doit être tes images de test, c'est tout.

Oui vous avez raison je vous remercie, du coup mnt j'affiche le résultat de max/2 et j'ai bien reussi en suivant la facon que vous m'avez montré et je veux afficher tous les positions (les i) correspondant à max/2 j'ai fais

Code :

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

1
2
3
4
5
6
if ( couleur[i]<=max/2 ) {
 
	        	 //System.out.println("Le max = "    +max); 
	        	 System.out.println("i  "  +i);
 
	         }

je veux afficher que le 1er i et non pas les differentes i qui existent !

[joel.drigo]

Oui, m'enfin avec if ( couleur[i]<=max/2 ) { tu vas afficher ceux qui sont inférieurs à max/2. La valeur la plus petite le sera ! Donc autant calculer le min au lieu du max... et afficher le min.

SI tu veux n'afficher qu'un seul alors qu'il y en a plusieurs, il te suffit d'utilser un booléen.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
boolean dejaAffiche=false;
 
for(int i=0; i<couleur.length; i++) {
 
    if ( couleur[i]==max && !dejaAffiche ) {
        System.out.println("max= "+max+" i="+i);
        dejaAffiche=true;
    }
 
}

[YOUHANA]

Oui merci, j'ai pensé au boolean aussi vu que vous m'avez deja expliquer ça autre part et ça à marcher parfaitement MERCI. Du coup par exemple



Voilà un histogramme et qu'on veut afficher les 2 premiès i de max/2 mais de deux cotés differentes !

[joel.drigo]

Voilà un histogramme et qu'on veut afficher les 2 premiès i de max/2 mais de deux cotés differentes !

Euh, c'est une autre question ça ?

[YOUHANA]

Oui excusez moi j'ai oublié de mettre le "?"

[joel.drigo]

Donc, je comprends bien tu cherches à indiquer, de part et d'autre, la première valeur supérieure (ou égale) au max/2 ?

Je ferais une boucle for(int i=0;i<couleur.length && couleur[i]!=max; i++). Dès que je détecte couleur[i]>=max/2 et que pas dejaAffiche j'affiche (et je passe le booléen dejaAffiche à true).
Puis je recommence en bouclant dans l'autre sens (en réinitialisant dejaAffiche à false bien sûr) : for(int i=couleur.length-1;i>=0 && couleur[i]!=max; i--).

[YOUHANA]

Bizzare parceque c'est exactement ce que j'avais fais (sans que j'ajoute le i>=0) avant de voir ton code, mais il me donne la derniere valeur de i et non la 1 ere valeur

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
  boolean dejaAffiche=false;
 
		   for(int i=0;i<couleur.length && couleur[i]!=max; i++){
 
		       if ( couleur[i]<=max/2 && !dejaAffiche ) {
 
		           dejaAffiche=true;
		           System.out.println("max= "+max+" i="+i);
		       }}
 
		   dejaAffiche=false;
		   for(int i=couleur.length-1;i>=0 && couleur[i]!=max; i--){
			   if ( couleur[i]<=max/2 && !dejaAffiche ) {
		           System.out.println("max= "+max+" i2 =  "+i);
		           dejaAffiche=true;
		       }}

[joel.drigo]

Ah, tu veux la première valeur de i après le max ? Je croyais que tu voulais quelque chose de symétrique.

Dans ce cas, il faut faire qu'une boucle évidemment. Tu devrais pouvoir quand même trouver ça toute seule...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
boolean dejaAffiche=false;
 
for(int i=0;i<couleur.length; i++){
 
    if ( couleur[i]<=max/2 && !dejaAffiche ) {
         // faire l'affichage
         dejaAffiche=true;
    }
    if ( couleur[i]==max ) {
         dejaAffiche=false; // on veut afficher la première valeur de i tel que couleur[i]<= max/2 après max
    }
 
}

Je ne comprends toujours pas ton <=max/2 mais bon c'est ton code...

[YOUHANA]

Ah, tu veux la première valeur de i après le max ? Je croyais que tu voulais quelque chose de symétrique.

Non enfaite je voulais le 1er "i" qui sa valeur est inferieur à max/2 à droite du max , puis le premier "i" qui sa valeur est inferieur à max/2 à gauche du max.
Par contre le résultat de mon code est le dernier "i" !

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
 boolean dejaAffiche=false;
 
		   for(int i=0;i<couleur.length && couleur[i]!=max; i++){
 
		       if ( couleur[i]<=max/2 && !dejaAffiche ) {
 
		           dejaAffiche=true;
		           System.out.println("max= "+max+" i="+i);
		       }}
 
		   dejaAffiche=false;
		   for(int i=couleur.length-1;i>=0 && couleur[i]!=max; i--){
			   if ( couleur[i]<=max/2 && !dejaAffiche ) {
		           System.out.println("max= "+max+" i2 =  "+i);
		           dejaAffiche=true;
		       }}

[joel.drigo]

Non enfaite je voulais le 1er "i" qui sa valeur est inferieur à max/2 à droite du max , puis le premier "i" qui sa valeur est inferieur à max/2 à gauche du max.

J'ai bien compris maintenant et je t'ai mis le code pour le faire !!!

[edit]evidemment, si tu as plusieurs max, tu auras le "premier i" après chaque max... pour n'avoir que pour le premier max, il faudrait un second booléen.

[YOUHANA]

Bonjour,
je reviens vers vous , je veux ne pas calculer que les valeurs différentes de 0xff000000) dans mon histogramme du coup je fais comme ça

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
   private void recupererRVB() { 
			   int[] rgbt = null;
			   int maximum = 0;
			      for (int y=0; y<image.getHeight(); y++)
			         for (int x=0; x<image.getWidth(); x++) {
			        	 int rgb=image.getRGB(x, y);
			        	 if (rgb!=0xff000000)
			             rgbt = toArray(rgb);
			            rouge[rgbt[0]]++;
			            vert[rgbt[1]]++;
			            bleu[rgbt[2]]++;
			         }          
			   }

Alors j'ai une erreur de null pointer pouvez vous m'aider svp ?

[joel.drigo]

Quand tu utilises une expression du type if ( condition ) statement, seul le statement (=instruction en français) est exécuté si la condition est vérifiée. Pour en exécuter plusieurs, ils doivent être dans un bloc.
Dans ton code, rgbt est initialisée null. Si le premier point testé a un rgb tel que rgb==0xff000000, alors rgbt reste null. Donc quand la ligne suivante (rouge[rgbt[0]]++;) est exécutée, tu obtiens une NullPointerException. C'est tout-à-fait logique.

Si pour une condition donnée, tu ne dois pas faire un calcul, à fortiori, on ne doit pas logiquement faire toute chose qui dépenderait de ce calcul.

Par ailleurs, si tu avais déclarer la variable à l'endroit où tu t'en sers, tu aurais naturellement éviter le probléme :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
int maximum = 0;
for (int y=0; y<image.getHeight(); y++)
   for (int x=0; x<image.getWidth(); x++) {
        int rgb=image.getRGB(x, y);
        int[] rgbt = toArray(rgb);
        rouge[rgbt[0]]++;
	vert[rgbt[1]]++;
	bleu[rgbt[2]]++;
	}          
}

Deviendra naturellement :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int maximum = 0;
for (int y=0; y<image.getHeight(); y++)
   for (int x=0; x<image.getWidth(); x++) {
        int rgb=image.getRGB(x, y);
        if ( rgb!=0xff000000) { // aucune des 4 lignes suivantes ne doit être exécutée si la condition n'est pas vérifiée
            int[] rgbt = toArray(rgb);
            rouge[rgbt[0]]++;
	    vert[rgbt[1]]++;
	    bleu[rgbt[2]]++;
	} 
   }         
}

Pour autant, j'aurais plutôt utilisé (rgb&0xffffff)==0 comme condition, qui fonctionne même pour des images avec transparence, mais si toutes tes images sont en RGB, pas de souci.

[YOUHANA]

Merci beaucoup !!
Enfaite j'avais déjà posé cette question mais j'ai pas eu de réponse, je profite pour vous la reposer, à chaque fois que j'essaye de faire des axes en X et en Y mon histogramme se déforme. Pouvez vous m'aidez svp ?

[joel.drigo]

Il va falloir être plus clair :

• "faire des axes en X et en Y ?" Je ne comprends pas ce que ça veut dire... "faire" = ?
• "mon histogramme se déforme" ? Se déforme ? C'est-à-dire ? Tu as un exemple (image) avec un histogramme non déformé et un histogramme déformé ?

[YOUHANA]

Merci pour votre retour,
"faire" genre dessiner des valeurs de 0 à 255 en i et de 0 à 255 en j.
Voilà mon histogramme


Et voilà mon code de dessin:

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
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
package STAGE;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Label;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.image.Raster;
import java.util.Random;
 
import javax.swing.JComponent;
 
 
public class Histogramme extends PanelImage {
 
	   private static final long serialVersionUID = 1L;
	   private BufferedImage image, histogramme;
	   private final int largeur = 256;
	   private final int hauteur = 200;
	   private final int[] rouge = new int[256];
	   private final int[] vert = new int[256];
	   private final int[] bleu = new int[256];
 
	   private int minBleu; // la valeur de seuil pour le bleu
	   private int minRouge; // la valeur de seuil pour le rouge
	   private int minVert; // la valeur de seuil pour le vert
	   private int maxRouge=0;
	   private int maxVert=0;
	   private int maxBleu=0;
	   private int sumRouge=0;
	   private int sumVert=0;
	   private int sumBleu=0;
	   private int medianeRouge=0;
	   private int medianeVert=0;
	   private int medianeBleu=0;
	    static int sum;
	    static int max;
	    static int position;
	    static int med;
	   public Histogramme(BufferedImage monImage){
		      image = monImage;
		      recupererRVB();
	              maxRouge = max(rouge);
	              maxVert = max(vert);
	              maxBleu = max(bleu);
	              sumRouge = sum(rouge,minRouge);
	              sumVert = sum(vert,minVert);
	              sumBleu = sum(bleu,minBleu);
	              medianeRouge = medianne(rouge,sumRouge);
	              medianeVert = medianne(vert,sumVert);
	              medianeBleu = medianne(bleu, sumBleu);
 
		      tracerHistogrammes();
		   }
 
	   public void setMax(int max) {
		this.max=max;
	}
	   public void Setsum(int sum) {
			this.sum=sum;
		}
	   public void Setmed(int med) {
			this.med=med;
		}
	   public void setMinBleu(int minBleu) {
	          this.minBleu=minBleu;
	          repaint(); // provoque un redessin
	   }
 
	   public void setMinRouge(int minRouge) {
	          this.minRouge=minRouge;
	          repaint(); // provoque un redessin
	   }
 
	   public void setMinVert(int minVert) {
	          this.minVert=minVert;
	          repaint(); // provoque un redessin
	   }
 
	   protected void paintComponent(Graphics surface) {
	     // surface.drawImage(image, 0, 0, null);  
	      surface.drawImage(histogramme,100, 100, null);
	   }
 
		   public int[] toArray(int argb) {
 
			   int[] array = new int[3];
 
			   array[0] = (argb >> 16 ) & 0xff;
			   array[1] = (argb >> 8 ) & 0xff;
			   array[2] = (argb) & 0xff;
 
			   return array;
	         } 
		   private void recupererRVB() { 
			   int maximum = 0;
			   for (int y=0; y<image.getHeight(); y++)
			      for (int x=0; x<image.getWidth(); x++) {
			           int rgb=image.getRGB(x, y);
			           if ( rgb!=0xff000000) { // aucune des 4 lignes suivantes ne doit être exécutée si la condition n'est pas vérifiée
			        int[] rgbt = toArray(rgb);
			        rouge[rgbt[0]]++;
			   	    vert[rgbt[1]]++;
			   	    bleu[rgbt[2]]++;
			           }} 
			      }   
 
 
	   private void tracerHistogrammes() {
	      histogramme = new BufferedImage(largeur, hauteur, BufferedImage.TYPE_INT_ARGB);
	      Graphics2D dessin = histogramme.createGraphics();
	      Rectangle2D rectangle = new Rectangle2D.Double(0, 0, largeur, hauteur);
	      dessin.setPaint(new Color(1F, 1F, 1F, 0.2F));
	      dessin.fill(rectangle);     
	      changerAxes(dessin);
	      dessin.setPaint(new Color(1F, 0F, 0F, 0.4F));
	      tracerHistogramme(dessin, rouge, minRouge, maxRouge, sumRouge, medianeRouge);
	      dessin.setPaint(new Color(0F, 1F, 0F, 0.4F));
	      tracerHistogramme(dessin, vert, minVert,maxVert,sumVert,medianeVert);
	      dessin.setPaint(new Color(0F, 0F, 1F, 0.4F));
	      tracerHistogramme(dessin, bleu, minBleu,maxBleu,sumBleu,medianeBleu);
 
 
	      dessin.dispose(); // toujours disposer aprés utilisation
 
 
	   }
 
	   private void changerAxes(Graphics2D dessin) {
	      dessin.translate(0, hauteur);
	      double surfaceImage = image.getWidth()*image.getHeight();
	      double surfaceHistogramme = histogramme.getWidth()*histogramme.getHeight();
	      dessin.scale(1, -surfaceHistogramme/surfaceImage/3.7);     
	   }  
 
	   private int max(int[] array) {
		     int max=0;
		     for(int i : array) {
		         max = Math.max(i,max);
		     }
		     return max;
		}
 
	   private int sum(int[] array, int min) {
		     int sum=0;
		     for(int i : array) {
		        // if ( i>min ) 
		        	 sum += i ;
		     }
		     return sum;
		}
 
	   private int medianne(int[] array, int sum) {
		   int val = -1;
		   int mediane=0;
		   for(int i=0; i<array.length; i++) {
		       mediane += array[i];
		       if(mediane>sum/2 ){
			     val=i;
		             break;
		       }
		   }
		   return val ;
		}
 
 
	   private void tracerHistogramme(Graphics2D dessin, int[] couleur, int min , int max, int somme, int mediane) {
 
		   for (int i=0; i<couleur.length; i++){
			   System.out.println(couleur[i]);
		        // if ( couleur[i]>min ) { 
		            dessin.drawLine(i, 0, i, couleur[i]); 
 
		         if ( couleur[i]==max ) {
		        	    position=i;
		         }
	         }
 
 
		 /*  boolean dejaAffiche=false;
 
		   for(int i=0;i<couleur.length; i++){
 
		       if ( couleur[i]<=max/2 && !dejaAffiche ) {
		            //System.out.println("Born A "  +i);
		            dejaAffiche=true;
		       }
		       if ( couleur[i]==max ) {
		    	   //System.out.println("Born B "  +i);
		            dejaAffiche=false; // on veut afficher la première valeur de i tel que couleur[i]<= max/2 après max
		       }
 
		   }*/
 
		   setMax(max);
		   Setsum(somme); 
		   Setmed(mediane);
	      }
	   }

[joel.drigo]

Et, donc, la version déformée ?