[Image] Matrice de cooccurrences et Haralick's Features

ToTo13 · 06/04/2008, 12h04

Bonjour,

voilà une dernière version pour le calcul de la matrice de cooccurrences d'une textures ou plutôt pour une vignette de la texture.
Dans cette nouvelle version, on peut désormais :

Modifier la distance entre le pixel étudié et le pixel référence (méthode setDistance).
Calculer la matrice dans une ou plusieurs directions (auquel cas on fait une moyenne).
Modifier la ou les directions de recherche (méthodeS setDirection).
Modifier la taille de la matrice (paramètre nbNiveauxGris du constructeur).
...

Code java :

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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
 
package rdf.textures.glcm;
 
import java.util.Arrays;
 
import imagetiti.Image;
 
/**
 * <p>Description : Classe qui calcule la matrice de cooccurrence pour une image (ou vignette) passee en argument.<br>
 *  Les explications sur la taille variable de la matrice de co-occurence se trouvent dans la these de Djamel BRAHMI.
 *  Sinon regarder le lien : <html>http://murphylab.web.cmu.edu/publications/boland/boland_node26.html</html>.<br></p>
 * <p>Packages necessaires : imagetiti.</p>
 * <p>Copyright : Copyright (c) 2007.</p>
 * <p>Laboratoire : LSIS.</p>
 * <p>Equipe : Image et Modele, I&M (ex LXAO).</p>
 * <p>Dernieres modifications :<br>
 * 7 Avril 2008 => Correction de bug dans le calcul de la moyenne des directions.<br>
 * 6 Avril 2008 => Decomposition en deux classes : GreyLevelCooccurrenceMatrix & Haralick. Ajout de la distance et modification des directions.<br>
 * 29 Octobre 2007 => JavaDoc + verification de bases.<br>
 * 26 septembre 2007 => Creation.</p>
 * 
 * @author Guillaume THIBAULT
 * @version 1.1
 */
 
 
public class GreyLevelCooccurrenceMatrix
{
 
/** Taille par defaut de la matrice de cooccurrences.*/
protected int MSIZE = 64 ;
/** Tableau representant la matrice de cooccurences.*/
protected double[][] matrix = new double[MSIZE][MSIZE] ; // matrices de densité spatiale (aka GLCM)
 
 
// Les directions de calcul.
/** La variation en X pour le calcul de la matrice.*/
protected int[] dx = new int[] {1, 1, 0,-1} ;
/** La variation en Y pour le calcul de la matrice.*/
protected int[] dy = new int[] {0, 1, 1, 1} ;
/** La distance par laquelle on va multiplier la direction.*/
protected int Distance = 3 ;
 
 
/** L'image (la vignette) sur laquelle on a calcule la matrice de cooccurrences.*/
protected Image image = null ; // image source
 
/** Variables egales a la somme de la matrice de cooccurence avant normalisation et moyenne.*/
protected int Sum, sum ;
 
 
 
/** Un constructeur vide.*/
public GreyLevelCooccurrenceMatrix()
	{
	}
 
 
/** Un constructeur qui permet de modifier la taille de la matrice de cooccurrences.
 * @param nbNiveauxGris Le nombre de niveaux de gris a prendre en compte, ce sera la taille de la matrice.*/
public GreyLevelCooccurrenceMatrix(int nbNiveauxGris)
	{
	if ( nbNiveauxGris < 2 || nbNiveauxGris > 256 )
		throw new Error("Parametre nbNiveauxGris incorrect : " + nbNiveauxGris + ", attendu [2..256]") ;
 
	this.MSIZE = nbNiveauxGris ;
 
	while ( nbNiveauxGris > 1 ) // On vérifie que nbNiveauxGris est une puissance de deux.
		{
		if ( nbNiveauxGris % 2 != 0 )
			throw new Error("Parametre nbNiveauxGris doit être une puissance de deux : " + MSIZE) ;
		nbNiveauxGris /= 2 ;
		}
	}
 
 
/** Methode qui affecte la distance de calcul. La distance etant la variable avec laquelle on multipliera la direction.
 * @param Distance La nouvelle distance, doit etre supperieure ou egale a 1.*/
public void setDistance(int Distance)
	{
	if ( Distance < 1 )
		throw new Error("Distance incorrecte : " + Distance) ;
	this.Distance = Distance ;
	}
 
 
/** Methode qui affecte la direction de calcul.
 * @param DX Deplacement en X.
 * @param DY Deplacement en Y.*/
public void setDirection(int DX, int DY)
	{
	dx = null ;
	dy = null ;
	dx = new int[]{DX} ;
	dy = new int[]{DY} ;
	}
 
 
/** Methode qui affecte le nouveau tableau de direction. Si le tableau a une taille superieure a 1, une moyenne sera faite.
 * @param dx Nouveau tableau de variation en X.
 * @param dy Nouveau tableau de variation en Y.*/
public void setDirection(int[] dx, int[] dy)
	{
	if ( dx == null || dy == null )
		throw new Error("Un des tableau est null.") ;
	if ( dx.length != dy.length )
		throw new Error("Tailles des deux tableaux différentes : " + dx.length + " & " + dy.length) ;
 
	this.dx = null ;
	this.dy = null ;
	this.dx = dx ;
	this.dy = dy ;
	}
 
 
/** Methode qui lance et gere les differentes etapes de calcul.*/
public void Calculer(Image image)
	{
	if ( image == null ) throw new Error("Paramètre image == null") ;
 
	int i, j ;
	this.image = image ;
 
	matrix = null ;
	matrix = new double[MSIZE][MSIZE] ;
 
	for (i=0 ; i < MSIZE ; i++)
		Arrays.fill(matrix[i], 0) ; // raz matrice
 
	Sum = 0 ;
 
	for (i=0 ; i < dx.length ; i++)
		computeMatrix(Distance*dx[i], Distance*dy[i]) ;
 
	// normalisation
	for (j=0 ; j < MSIZE ; j++)
		for (i=0 ; i < MSIZE ; i++)
			matrix[i][j] /= (double)Sum ;
 
	//Moyenne
	for (j=0 ; j < MSIZE ; j++)
		for (i=0 ; i < MSIZE ; i++)
			matrix[i][j] /= (double)dx.length ;
	}
 
 
 
/** Methode qui effectue le remplissage de la matrice de cooccurrence.
 * @param dx Variation de calcul en X.
 * @param dy Variation de calcul en Y.*/
protected void computeMatrix(int dx, int dy)
	{
	int x, y, x1, y1, v0, v1 ;
	int height = image.getHeight() ;
	int width = image.getWidth() ;
	sum = 0 ;
 
	// calcul des cooccurences
	for (y=0 ; y < height ; y++)
		for (x=0 ; x < width ; x++)
			{ // pour chaque pixel
			v0 = (int)((double)MSIZE*(double)this.image.getPix(y, x)/256.0) ;
 
			// on cherche le voisin
			x1 = x + dx ;
			if ( x1 < 0 || x1 >= width ) continue ;
			y1 = y + dy ;
			if ( y1 < 0 || y1 >= height ) continue ;
			v1 = (int)((double)MSIZE*(double)this.image.getPix(y1, x1)/256.0) ;
 
			// on incrémente la matrice
			matrix[v0][v1]++ ;
			matrix[v1][v0]++ ;
			sum += 2 ;
			}
 
	Sum += sum ;
	}
 
 
 
 
 
/* ------------------------------------------------------ Les getters ------------------------------------------------------ */
/** Methode qui renvoie la taille de la matrice de cooccurrence.
 * @return Taille de la matrice de cooccurrence.*/
public int getMSIZE()
	{
	return MSIZE ;
	}
 
/** Methode qui retourne la matrice de cooccurrence.
 * @return Le tableau de double[][] contenant la matrice de cooccurrence.*/
public double[][] getMatrix()
	{
	return matrix ;
	}
 
/** Tableau d'int contenant la variation de direction en X.
 * @return Direction en X.*/
public int[] getDx()
	{
	return dx ;
	}
 
/** Tableau d'int contenant la variation de direction en Y.
 * @return Direction en Y.*/
public int[] getDy()
	{
	return dy ;
	}
 
/** Methode qui revoit la distance de travail.
 * @return La distance.*/
public int getDistance()
	{
	return Distance ;
	}
 
public String toString()
	{
	StringBuffer sb = new StringBuffer() ;
	for (int j=0 ; j < MSIZE ; j++)
		{
		for (int i=0 ; i < MSIZE ; i++) sb.append(matrix[i][j] + " ") ;
		sb.append("\n") ;
		}
	return sb.toString() ;
	}
}

ToTo13 · 06/04/2008, 12h07

Et voilà la classe Haralick qui étend la classe précédente afin de calculer les Haralick's Features de la vignette de texture passée en argument.

Code java :

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
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
package rdf.textures.glcm;
 
import java.util.Arrays;
 
import imagetiti.Image;
 
/**
 * <p>Description : Classe qui calcule onze caracteristiques Haralick et quatre caracteristiques supplementaires.
 *  Grandement inspiree du code recupere sur Developpez.net et produit par Xavier Philippeau.<br>
 *  Toutes les formules presentees ainsi que les explications sur la taille variable de la matrice de cooccurrence se trouvent dans la these de Djamel BRAHMI.
 *  Sinon regarder le lien : <html>http://murphylab.web.cmu.edu/publications/boland/boland_node26.html</html>.<br>
 *  Les indices F1 a F11 sont des Haralick's Features, les autres sont des ajouts perso.<br>
 *  - Moyenne<br>
 *  - F1 - Second moment angulaire (homogeneite), egale a l'energie.<br>
 *  - F2 - Contraste<br>
 *  - F3 - Correlation<br>
 *  - F4 - Variance<br>
 *  - F5 - Moment des différences inverses OK<br>
 *  - F6 - Moyenne des sommes<br>
 *  - F7 - Variance des sommes<br>
 *  - F8 - Entropie des sources<br>
 *  - F9 - Entropie<br>
 *  - F10 - Variance des differences<br>
 *  - F11 - Entropie des differences<br>
 *  - Dissimilarite<br>
 *  - Homogeneite<br>
 *  - Inertie<br>
 *  </p>
 * <p>Packages necessaires : imagetiti.</p>
 * <p>Copyright : Copyright (c) 2007.</p>
 * <p>Laboratoire : LSIS.</p>
 * <p>Equipe : Image et Modele, I&M (ex LXAO).</p>
 * <p>Dernieres modifications :<br>
 * 7 Avril 2008 => Mise a jour en fonction de la correction du bug dans GreyLevelCooccurrenceMatrix.<br>
 * 6 Avril 2008 => Decomposition en deux classes : GreyLevelCooccurrenceMatrix & Haralick.<br>
 * 29 Octobre 2007 => JavaDoc + verifications de bases.<br>
 * 26 septembre 2007 => Creation.</p>
 * 
 * @author Guillaume THIBAULT
 * @version 1.1
 * @see GreyLevelCooccurrenceMatrix
 */
 
 
public class Haralick extends GreyLevelCooccurrenceMatrix
{
 
// precalculs
private double[] px_y = new double[MSIZE] ;  // Px-y(i)
private double[] pxy = new double[2*MSIZE] ; // Px+y(i)
 
/** Le tableau contenant les Haralick's Features.*/
private double[] features = new double[15] ; // valeurs specifiques de la texture
 
 
 
 
/**Constructeur, par defaut la dimension de la matrice de co-occurence est de 16.
 * @param image image (vignette) de la texture a analyser.*/
public Haralick()
	{
	super() ;
	}
 
 
/**Constructeur
 * @param nbNiveauxGris Nombre de niveau de gris qui va engendrer la dimension de la matrice de cooccurrences. Lire les proprietes dans la these cite ci-dessus.*/
public Haralick(int nbNiveauxGris)
	{
	super(nbNiveauxGris) ;
	}
 
 
 
/** Methode qui lance et gere les differentes etapes de calcul.*/
public void Calculer(Image image)
	{
	if ( image == null ) throw new Error("Paramètre image == null") ;
	this.image = image ;
	int i, x, y, n = dx.length ;
	double mean, f6 ;
 
	matrix = null ; // Raz matrix
	matrix = new double[MSIZE][MSIZE] ;
 
	for(i=0 ; i < this.features.length ; i++) this.features[i] = 0.0 ; // raz features.
 
	for (i=0 ; i < n ; i++)
		{
		RazMatrix() ;
 
		computeMatrix(Distance*dx[i], Distance*dy[i]) ;
		precomputation() ;
 
		for (y=0 ; y < MSIZE ; y++)
			for (x=0 ; x < MSIZE ; x++)
				matrix[y][x] /= sum ;
 
		mean = Moyenne() ;
		this.features[0] += mean ; // F0 - Moyenne
		this.features[1] += getF1() ; // F1 - Second moment angulaire (homogénéité), Egal à l'énergie
		this.features[2] += getF2() ; // F2 - Contraste
		this.features[3] += getF3() ; // F3 - Corrélation
		this.features[4] += getF4(mean) ; // F4 - Variance
		this.features[5] += getF5() ; // F5 - Moment des différences inverses OK
		f6 = getF6() ;
		this.features[6] += f6 ; // F6 - Moyenne des sommes
		this.features[7] += getF7(f6) ; // F7 - Variance des sommes
		this.features[8] += getF8() ; // F8 - Entropie des sources
		this.features[9] += getF9() ; // F9 - Entropie
		this.features[10] += getF10() ; // F10 - Variance des différences
		this.features[11] += getF11() ; // F11 - Entropie des différences
		this.features[12] += Dissimilarite() ;
		this.features[13] += Homogeneite() ;
		this.features[14] += Inertie() ;
		}
 
	for(i=0 ; i < this.features.length ; i++) this.features[i] /= (double)n ;
	}
 
 
 
/** Methode qui remet a zero la matrice.*/
private void RazMatrix()
	{
	for (int i=0 ; i < MSIZE ; i++)
		for (int j=0 ; j < MSIZE ; j++)
			matrix[i][j] = 0.0 ;
	}
 
 
 
/* ----------------------------------------- Calculs preliminaires et remplissage de la matrice ----------------------------------------- */
private void precomputation()
	{
	int i, j ;
 
	Arrays.fill(px_y, 0) ; // Px-y(i)
	for (j=0 ; j < MSIZE ; j++)
		for(i=0 ; i < MSIZE ; i++)
			px_y[Math.abs(i-j)] += matrix[i][j] ;
 
	Arrays.fill(pxy, 0) ; // Px+y(i)
	for (j=0 ; j < MSIZE ; j++)
		for (i=0 ; i < MSIZE ; i++)
			pxy[i+j] += matrix[i][j] ;
	}
 
 
 
 
 
 
/* --------------------------------------------------------- Calcul des caracteristiques --------------------------------------------------------- */
/** Methode qui calcule la moyenne.
 * @return La moyenne.*/
private double Moyenne()
	{
	double mean = 0.0 ;
	for (int j=0 ; j < MSIZE ; j++)
		for (int i=0 ; i < MSIZE ; i++)
			mean += matrix[i][j] ;
	return mean / (double)(MSIZE*MSIZE) ;
	}
 
 
 
/** F1 - Methode qui calcule l'angle du moment du second ordre : ASM (homogeneite). Egal a la formule de l'energie.
 * @return L'angle du moment du second ordre.*/
private double getF1()
	{
	double h = 0.0	 ;
	for (int j=0 ; j < MSIZE ; j++)
		for (int i=0 ; i < MSIZE ; i++)
			h += Math.pow(matrix[i][j], 2.0) ;
	return h ;
	}
 
 
 
/** F2 - Methode qui calcule le contrast.
 * @return Le contrast.*/
private double getF2()
	{
	double contrast = 0.0 ;
	for (int n=0 ; n < MSIZE ; n++)
		for (int j=0 ; j < MSIZE ; j++)
			for (int i=0 ; i < MSIZE ; i++)
				if ( Math.abs(i-j) == n )
					contrast += Math.pow((double)n, 2.0) * matrix[i][j] ;
	return contrast ;
	}
 
 
 
/** F3 - Methode qui calcule la correlation.
 * @return La correlation.*/
private double getF3()
	{ // optimisation car matrice symetrique ==> distribution marginale sur X = distribution marginale sur Y. moyenne = somme { p(i,j) * i }
	int i, j ;
 
	double md_mean = 0.0 ;
	for (i=0 ; i < MSIZE ; i++)
		for(j=0 ; j < MSIZE ; j++)
			md_mean += (double)i*matrix[i][j] ;
 
	double md_var = 0.0 ; // variance = somme { p(i,j) * (i-moyenne)^2 }
	for (i=0 ; i < MSIZE ; i++)
		for (j=0 ; j < MSIZE ; j++)
			md_var += matrix[i][j]*((double)i-md_mean)*((double)i-md_mean) ;
 
	if ( md_var <= 0.0 ) return 1.0 ;
 
	double sum = 0.0 ; // correlation = somme { (i-moyenne) * (j-moyenne) * p(i,j) / variance^2 }
	for(j=0 ; j < MSIZE ; j++)
		for(i=0 ; i < MSIZE ; i++)
			sum += matrix[i][j] * ((double)i-md_mean)*((double)j-md_mean) ;
 
	return sum/(md_var*md_var) ;
	}
 
 
 
/** F4 - Methode qui calcule la variance.
 * @return La variance.*/
private double getF4(double mean)
	{
	double variance = 0.0 ;
	for (int j=0 ; j < MSIZE ; j++)
		for (int i=0 ; i < MSIZE ; i++)
			variance += Math.pow((double)i-mean, 2.0)*matrix[i][j] ;
	return variance ;
	}
 
 
 
/** F5 - Methode qui calcule la difference inverse.
 * @return La difference inverse.*/
private double getF5()
	{
	double coef, invdiff = 0.0 ;
	for (int j=0 ; j < MSIZE ; j++)
		for(int i=0 ; i < MSIZE ; i++)
			{
			coef = 1.0 / (1.0+Math.pow((double)(i-j), 2.0)) ; 
			invdiff += coef*matrix[i][j] ;
			}
	return invdiff ;
	}
 
 
 
/** F6 - Methode qui calcule la moyenne des sommes.
 * @return La moyenne des sommes.*/
private double getF6()
	{
	double sumavg = 0.0 ;
	for(int k=0 ; k < 2*(MSIZE-1) ; k++) sumavg += (double)k * pxy[k] ;
	return sumavg ;
	}
 
 
 
/** F7 - Methode qui calcule la variance des sommes.
 * @return La variance des sommes.*/
private double getF7(double f6)
	{
	double sumavg = f6 ;
	int sumvar = 0 ;
	for (int k=0 ; k < 2*(MSIZE-1) ; k++) sumvar += (k-sumavg) * (k-sumavg) * pxy[k] ;
	return sumvar ;
	}
 
 
 
/** F8 - Methode qui calcule l'entropie des sources.
 * @return L'entropie des sources.*/
private double getF8()
	{
	double entropysrc = 0.0 ;
	for(int k=0 ; k < 2*(MSIZE-1) ; k++)
		{
		if ( pxy[k] == 0 ) continue ;
		entropysrc += pxy[k] * Math.log(pxy[k]) ;
		}
	return -entropysrc ;	
	}
 
 
 
/** F9 - Methode qui calcule l'entropie.
 * @return L'entropie.*/
private double getF9()
	{
	double entropy = 0.0 ;
	for (int j=0 ; j < MSIZE ; j++)
		for (int i=0 ; i < MSIZE ; i++)
			{
			if ( matrix[i][j] == 0 ) continue ;
			entropy += matrix[i][j] * Math.log(matrix[i][j]) ;
			}
	return -entropy ;
	}
 
 
 
/** F10 - Methode qui calcule la variance des differences.
 * @return La variance des differences.*/
private double getF10()
	{
	int k ;
	double mean = 0.0 ;
	for (k=0 ; k < MSIZE-1 ; k++) mean += k * px_y[k] ;
	double var = 0.0 ;
	for (k=0 ; k < MSIZE-1 ; k++) var += Math.pow((double)k-mean, 2.0) * px_y[k] ;
	return var ;
	}
 
 
 
/** F4 - Methode qui calcule l'entropie des differences.
 * @return L'entropie des differences.*/
private double getF11()
	{
	double entropydiff = 0.0 ;
	for (int k=0 ; k < MSIZE-1 ; k++)
		{
		if ( px_y[k] == 0.0 ) continue ;
		entropydiff += px_y[k] * Math.log(px_y[k]) ;
		}
	return -entropydiff ;
	}
 
 
 
/** Methode qui calcule la homogeneite.
 * @return La homogeneite.*/
private double Homogeneite()
	{
	double homogeneity = 0.0 ;
	for(int j=0 ; j < MSIZE ; j++)
		for(int i=0 ; i < MSIZE ; i++)
			homogeneity += matrix[i][j] / (1.0+Math.abs(i-j)) ;
	return homogeneity ;
	}
 
 
 
/** Methode qui calcule la dissimilarite.
 * @return La dissimilarite.*/
private double Dissimilarite()
	{
	double dissimilarity = 0.0 ;
	for(int j=0 ; j < MSIZE ; j++)
		for(int i=0 ; i < MSIZE ; i++)
			dissimilarity += matrix[i][j] * Math.abs(i-j) ;
	return dissimilarity ;
	}
 
 
 
/** Methode qui calcule l'inertie.
 * @return L'.*/
private double Inertie()
	{
	double inertie = 0.0 ;
	for(int j=0 ; j < MSIZE ; j++)
		for(int i=0 ; i < MSIZE ; i++)
			inertie += matrix[i][j] * Math.pow(i-j, 2.0) ;
	return inertie ;
	}
 
 
 
 
 
 
 
 
/* ---------------------------------------------------- Les getters ---------------------------------------------------- */
/** Methode qui retourne la liste des caracteristiques.
 * @return Le tableau de double contenant les caracteristiques.*/
public double[] getFeatures()
	{
	return features ;
	}
 
 
 
/** Methode qui retourne une des caracteristiques.
 * @return La valeur de type double de la caracteristiques.*/
public double getF(int i)
	{
	if ( i < 0 || i >= features.length )
		throw new Error("Numéro de Haralick's Features incorrect : " + i + ", attendu [0.." + (features.length-1) + "].") ;
	return features[i] ;
	}
}

Sainsi · 21/10/2008, 19h20

Bonjour, bonsoir

je poste ici afin si possible d'obtenir des réponses.
Pour un mes cours, je dois programmer la matrice de co-occurrence.

Je pense avoir compris le principe (bien que j'hésite quand même).
De ce que je pense avoir compris, il ressort ceci :

On prend une image qui sert de texture. Avec celle-ci on cree une matrice.
Ensuite a partir d'une image quelconque (préalablement choisie si on veut un résultat parlant) on la parcoure avec la matrice et on regarde si elle s'y retrouve.
Mais après je ne sais pas ce qu'il faut faire. Par exemple lorsque j'ai trouvé une zone qui correspond.

de plus il me reste quand même quelque zone d'ombre dans l'algorithme posté sur le forum.

1) la fonction computematrix ()
si j'ai bien compris, elle sert a remplir la matrice de co-occurrence.
hors au début de ton code tu définis le MSIZE a 64.
et pourtant tu utilise les width et le height de l'image pour remplir ta matrice. Donc cela peut posé problème dans le cas d'une image plus grande que 64.
et tu définis un espace trop grand dans le cas contraire.
J'en arrive donc a la conclusion qu'il faut nécessairement une image de 64X64 pour utilisé ton code.

2) pourquoi faire une moyenne et une normalisation après avoir fait la matrice.

voila merci, de m'avoir lu.
sainsi

ToTo13 · 22/10/2008, 00h19

Bonsoir,

Citation:

Envoyé par Sainsi

1) la fonction computematrix ()
si j'ai bien compris, elle sert a remplir la matrice de co-occurrence.
hors au début de ton code tu définis le MSIZE a 64.
et pourtant tu utilise les width et le height de l'image pour remplir ta matrice. Donc cela peut posé problème dans le cas d'une image plus grande que 64.
et tu définis un espace trop grand dans le cas contraire.
J'en arrive donc a la conclusion qu'il faut nécessairement une image de 64X64 pour utilisé ton code.

MSIZE est la variable pour définir la taille de la matrice de cooccurrences (matrix size). La taille de la matrice de cooccurrences dépend du nombre de niveaux de gris de l'image et non de la taille de l'image.
On va stocker dans la matrice les couples de valeurs de pixels, donc des couples de niveaux de gris, d'où le fait que la matrice dépende du nombre de niveaux de gris et non de la taille.

Citation:

Envoyé par Sainsi

2) pourquoi faire une moyenne et une normalisation après avoir fait la matrice.

Il est toujours préférable de travailler avec des valeurs normées. Cela va permettre notemment de travailler avec des matrices issues d'images de tailles différentes.
Pour la moyenne c'est lorsque je calcule la matrice dans plusieurs directions.

Sainsi · 02/11/2008, 18h13

encore merci pour les explication.

Mais par contre, j'ai encore une question.

la méthode calculer, elle calcul, la matrice, mais une fois la matrice calculé, que faut-il faire pour l'appliqué a l'image.

Si j'ai bien compris, a partir d'une texture, en niveau de gris, on calcul une matrice, ensuite on applique cette matrice a une image.

Si j'ai tords dites-le.

mais comment appliqué cette matrice a une image, que doit faire cette matrice ?

ToTo13 · 04/11/2008, 15h37

Bonjour,

non, ce n'est pas ça

On calcule la matrice à partir d'une texture => ça ok.
Ensuite, tu peux comparer des textures entres elles à partir de la matrice ou des caractéristiques Haralick.
Pour le cas d'une image, tu peux au mieux retrouver où cette texture ce situe. Pour cela, on fait généralement glisser une petite fenêtre dans l'image et pour chaque position de la fenêtre, on calcule la matrice de cooccurrences sur la texture se trouvant dans la fenêtre et si nécessaire les caractéristiques Haralick.

wamajed · 30/03/2010, 10h34

binjour,
avec quels degrés tu travailles pour construire la matrice de co-occurrence

ToTo13 · 30/03/2010, 10h36

Citation:

Envoyé par wamajed

avec quels degrés tu travailles pour construire la matrice de cooccurrences

Degrés ???

Qu'appelles tu le degrés ? Le nombre de niveaux de gris ?

wamajed · 30/03/2010, 14h46

non pour déterminer une matrice de cooccurrence il faut que tu détermines :
– d : la distance entre les 2 pixels
– θ : l'angle de la droite reliant ces 2 pixels par rapport à l'horizontale

Valeurs généralement utilisées :
– d=1
– θ=0°, θ=45°, θ=90°, θ=135°

ToTo13 · 30/03/2010, 14h59

Bonjour,

la méthode setDistance permet de déterminer la distance et les tableaux dx/dy donnent les directions.
Si rien n'est spécifié, il y a un calcul dans les quatre direction suivi d'une moyenne.
Sinon, on peut passer les directions en argument.

wamajed · 31/03/2010, 12h01

Citation:

Envoyé par ToTo13

Bonjour,

la méthode setDistance permet de déterminer la distance et les tableaux dx/dy donnent les directions.
Si rien n'est spécifié, il y a un calcul dans les quatre direction suivi d'une moyenne.
Sinon, on peut passer les directions en argument.

Comment par exemple t'as pu déterminer une direction (1,45°) avec ces deux méthodes??

ToTo13 · 01/04/2010, 11h22

Citation:

Envoyé par wamajed

Comment par exemple t'as pu déterminer une direction (1,45°) avec ces deux méthodes??

Code java :

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

1
2
3
 
setDirection(1,1) ; // 45°
setDistance(1) ;

Si rien n'est spécifié c'est le calcul dans quatre direction et la moyenne des résultats.

04/11/2008, 15h37	#6
ToTo13 Modérateur Guillaume Chercheur en informatique Inscription : janvier 2006 Messages : 4 405 Détails du profil Informations personnelles : Nom : Guillaume Âge : 33 Localisation : France Informations professionnelles : Activité : Chercheur en informatique Secteur : Santé Informations forums : Inscription : janvier 2006 Messages : 4 405 Points : 5 267 Points : 5 267	Bonjour, non, ce n'est pas ça On calcule la matrice à partir d'une texture => ça ok. Ensuite, tu peux comparer des textures entres elles à partir de la matrice ou des caractéristiques Haralick. Pour le cas d'une image, tu peux au mieux retrouver où cette texture ce situe. Pour cela, on fait généralement glisser une petite fenêtre dans l'image et pour chaque position de la fenêtre, on calcule la matrice de cooccurrences sur la texture se trouvant dans la fenêtre et si nécessaire les caractéristiques Haralick. __________________ Consignes aux jeunes padawans : une image vaut 1000 mots ! - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe correcteur orthographique pour FiReFox), mettre les ACCENTS et les BALISES => ECRIRE clairement et en Français tu DOIS. - Le coté obscur je sens dans le MP => Tous tes MP je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci) - ton poste tu dois marquer quand la bonne réponse tu as obtenu.
	00

30/03/2010, 14h59	#10
ToTo13 Modérateur Guillaume Chercheur en informatique Inscription : janvier 2006 Messages : 4 405 Détails du profil Informations personnelles : Nom : Guillaume Âge : 33 Localisation : France Informations professionnelles : Activité : Chercheur en informatique Secteur : Santé Informations forums : Inscription : janvier 2006 Messages : 4 405 Points : 5 267 Points : 5 267	Bonjour, la méthode setDistance permet de déterminer la distance et les tableaux dx/dy donnent les directions. Si rien n'est spécifié, il y a un calcul dans les quatre direction suivi d'une moyenne. Sinon, on peut passer les directions en argument. __________________ Consignes aux jeunes padawans : une image vaut 1000 mots ! - Dans ton message respecter tu dois : les règles de rédaction et du forum, prévisualiser, relire et corriger TOUTES les FAUTES (frappes, sms, d'aurteaugrafe correcteur orthographique pour FiReFox), mettre les ACCENTS et les BALISES => ECRIRE clairement et en Français tu DOIS. - Le coté obscur je sens dans le MP => Tous tes MP je détruirai et la réponse tu n'auras si en privé tu veux que je t'enseigne.(Lis donc ceci) - ton poste tu dois marquer quand la bonne réponse tu as obtenu.
	00

21/10/2008, 19h20	#3
Sainsi Invité de passage Inscription : octobre 2008 Messages : 2 Détails du profil Informations personnelles : Âge : 27 Informations forums : Inscription : octobre 2008 Messages : 2 Points : 2 Points : 2	Bonjour, bonsoir je poste ici afin si possible d'obtenir des réponses. Pour un mes cours, je dois programmer la matrice de co-occurrence. Je pense avoir compris le principe (bien que j'hésite quand même). De ce que je pense avoir compris, il ressort ceci : On prend une image qui sert de texture. Avec celle-ci on cree une matrice. Ensuite a partir d'une image quelconque (préalablement choisie si on veut un résultat parlant) on la parcoure avec la matrice et on regarde si elle s'y retrouve. Mais après je ne sais pas ce qu'il faut faire. Par exemple lorsque j'ai trouvé une zone qui correspond. de plus il me reste quand même quelque zone d'ombre dans l'algorithme posté sur le forum. 1) la fonction computematrix () si j'ai bien compris, elle sert a remplir la matrice de co-occurrence. hors au début de ton code tu définis le MSIZE a 64. et pourtant tu utilise les width et le height de l'image pour remplir ta matrice. Donc cela peut posé problème dans le cas d'une image plus grande que 64. et tu définis un espace trop grand dans le cas contraire. J'en arrive donc a la conclusion qu'il faut nécessairement une image de 64X64 pour utilisé ton code. 2) pourquoi faire une moyenne et une normalisation après avoir fait la matrice. voila merci, de m'avoir lu. sainsi
	00

02/11/2008, 18h13	#5
Sainsi Invité de passage Inscription : octobre 2008 Messages : 2 Détails du profil Informations personnelles : Âge : 27 Informations forums : Inscription : octobre 2008 Messages : 2 Points : 2 Points : 2	encore merci pour les explication. Mais par contre, j'ai encore une question. la méthode calculer, elle calcul, la matrice, mais une fois la matrice calculé, que faut-il faire pour l'appliqué a l'image. Si j'ai bien compris, a partir d'une texture, en niveau de gris, on calcul une matrice, ensuite on applique cette matrice a une image. Si j'ai tords dites-le. mais comment appliqué cette matrice a une image, que doit faire cette matrice ?
	00

30/03/2010, 10h34	#7
wamajed Invité régulier Majed oualha Inscription : mars 2010 Messages : 14 Détails du profil Informations personnelles : Nom : Majed oualha Informations forums : Inscription : mars 2010 Messages : 14 Points : 8 Points : 8	binjour, avec quels degrés tu travailles pour construire la matrice de co-occurrence
	00

30/03/2010, 14h46	#9
wamajed Invité régulier Majed oualha Inscription : mars 2010 Messages : 14 Détails du profil Informations personnelles : Nom : Majed oualha Informations forums : Inscription : mars 2010 Messages : 14 Points : 8 Points : 8	non pour déterminer une matrice de cooccurrence il faut que tu détermines : – d : la distance entre les 2 pixels – θ : l'angle de la droite reliant ces 2 pixels par rapport à l'horizontale Valeurs généralement utilisées : – d=1 – θ=0°, θ=45°, θ=90°, θ=135°
	00

Outils de la discussion
Afficher une version imprimable Envoyer un lien vers cette page par email