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
| package rdf.textures.glrlm;
import imagetiti.Image;
/**
* <p>Description : Cette classe calcule les caracteristiques de la "run length matrix" pour une image (vignette). Elles peuvent etre calculees
* dans plusieurs directions, mais dans ce dernier cas, une moyenne sera faite.<br>
* Liste des caracteristiques calculees :<br>
* - F0 => Short Run Emphasis, SRE.<br>
* - F1 => LONG Run Emphasis, LRE.<br>
* - F2 => Gray Level Non Uniformity, GLNU.<br>
* - F3 => Run Length Non Uniformity, RLNU.<br>
* - F4 => Run Percentage, RP.<br>
* - F5 => Low Gray Level Run Emphasis, LGLRE.<br>
* - F6 => High Gray Level Run Emphasis, HGLRE.<br>
* - F7 => Short Run Low Gray Level Emphasis, SRLGLE.<br>
* - F8 => Short Run High Gray Level Emphasis, SRHGLE.<br>
* - F9 => Long Run Low Gray Level Emphasis, LRLGLE.<br>
* - F10 => Long Run High Gray Level Emphasis, LRHGLE.<br>
* Inspire des articles suivants :<br>
* - K. Yogesan and T. Jørgensen and F. Albregtsen and K. J. Tveter and H. E. Danielsen, Entropy based texture analysis of chromatin structure in advanced
* prostate cancer. In 1996 in Cytometry, volume 24, pages 268-276.<br>
* - S. A. Karkanis and George D. Magoulas and Maria Grigoriadou and Dimitris A. Karras, Neural Network based textural labeling of images in multimedia
* applications. In 1999 in EUROMICRO, volume 2, pages 392-396.<br>
* - D.-H. Xu and A.S. Kurani and J.D. Furst and D.S. Raicu, Run-Length Encoding For Volumetric Texture. In 2004 in International Conference on Visualization,
* Imaging, and Image Processing (VIIP), pages 452-458.<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>
* 8 Avril 2008 => Creation.</p>
*
* @author Guillaume THIBAULT
* @version 1.0
*/
public class GlrlmFeatures extends GreyLevelRunLengthMatrix
{
/** Tableau qui va contenir toutes les caracteristiques.*/
private double[] Features = new double[11] ;
/** Variable qui va etre egale a la somme de tous les elements de la matrice.*/
private double Sum = 0.0 ;
/** Un simple constructeur vide.*/
public GlrlmFeatures()
{
super() ;
}
/** Un constructeur qui permet de modifier la taille de la run length matrix.
* @param nbNiveauxGris Le nombre de niveaux de gris a prendre en compte, ce sera la hauteur de la matrice.*/
public GlrlmFeatures(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 x, y, i ;
int max ;
for (i=0 ; i < Features.length ; i++) Features[i] = 0.0 ;
for (i=0 ; i < dx.length ; i++)
{
if ( image.getWidth() > image.getHeight() ) largeur = image.getWidth() + 1 ;
else largeur = image.getHeight() + 1 ;
matrix = null ;
matriceajustee = null ;
matrix = new double[nbNiveauxGris][largeur] ;
for (y=0 ; y < nbNiveauxGris ; y++)
for (x=0 ; x < largeur ; x++)
matrix[y][x] = 0.0 ; // raz matrix
computeMatrix(dx[i], dy[i]) ;
// Moyenne
for (y=0 ; y < nbNiveauxGris ; y++)
for (x=0 ; x < largeur ; x++)
matrix[y][x] /= (double)dx.length ;
// On trouve la largeur de la matrice.
max = 0 ;
for (y=0 ; y < nbNiveauxGris ; y++)
for (x=0 ; x < largeur ; x++)
if ( matrix[y][x] > 0.0 && x > max ) max = x ;
// On trouve la largeur pour ajuster puis on moyenne
largeur = max + 1 ;
matriceajustee = new double[nbNiveauxGris][largeur] ;
for (y=0 ; y < nbNiveauxGris ; y++)
for (x=0 ; x < largeur ; x++)
matriceajustee[y][x] = matrix[y][x] ;
Sum = 0.0 ;
for (y=0 ; y < nbNiveauxGris ; y++)
for (x=0 ; x < largeur ; x++)
Sum += matriceajustee[y][x] ;
Features[0] += SRE() ;
Features[1] += LRE() ;
Features[2] += GLNU() ;
Features[3] += RLNU() ;
Features[4] += RP() ;
Features[5] += LGLRE() ;
Features[6] += HGLRE() ;
Features[7] += SRLGLE() ;
Features[8] += SRHGLE() ;
Features[9] += LRLGLE() ;
Features[10] += LRHGLE() ;
}
// On fait la moyenne.
for (i=0 ; i < Features.length ; i++) Features[i] /= (double)dx.length ;
}
/* ------------------------------------------------- Calcul des caractéristiques ------------------------------------------------- */
/** F0 - Short Run Emphasis, SRE. Courte isolongueur.
* @return SRE.*/
private double SRE()
{
int n, l ;
double val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
for (l=0 ; l < largeur ; l++)
val += matriceajustee[n][l] / Math.pow(l+1, 2.0) ;
return val / Sum ;
}
/** F1 - Long Run Emphasis, LRE. Grande isolongueur.
* @return LRE.*/
private double LRE()
{
int n, l ;
double val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
for (l=0 ; l < largeur ; l++)
val += matriceajustee[n][l] * Math.pow(l+1, 2.0) ;
return val / Sum ;
}
/** F2 - Gray Level Non Uniform, GLNU. Homogeneite spectrale.
* @return GLNU.*/
private double GLNU()
{
int n, l ;
double v, val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
{
v = 0.0 ;
for (l=0 ; l < largeur ; l++)
v += matriceajustee[n][l] ;
val += v*v ;
}
return val / Sum ;
}
/** F3 - Run Length Non Uniform, RLNU. Uniformite.
* @return RLNU.*/
private double RLNU()
{
int n, l ;
double v, val = 0.0 ;
for (l=0 ; l < largeur ; l++)
{
v = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
v += matriceajustee[n][l] ;
val += v*v ;
}
return val / Sum ;
}
/** F4 - Run Percentage, RP. Egalite des isolongueur (pourcentage primitives).
* @return RP.*/
private double RP()
{
int n, l ;
double val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
for (l=0 ; l < largeur ; l++)
val += (double)(l+1) * matriceajustee[n][l] ;
return Sum / val ;
}
/** F5 - Low Gray Level Run Emphasis, LGLRE.
* @return LGLRE.*/
private double LGLRE()
{
int n, l ;
double val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
for (l=0 ; l < largeur ; l++)
val += matriceajustee[n][l] / Math.pow(n+1, 2.0) ;
return val / Sum ;
}
/** F6 - High Gray Level Run Emphasis, HGLRE.
* @return LGLRE.*/
private double HGLRE()
{
int n, l ;
double val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
for (l=0 ; l < largeur ; l++)
val += matriceajustee[n][l] * Math.pow(n+1, 2.0) ;
return val / Sum ;
}
/** F7 - Short Run Low Gray Level Emphasis, SRLGLE.
* @return SRLGLE.*/
private double SRLGLE()
{
int n, l ;
double val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
for (l=0 ; l < largeur ; l++)
val += matriceajustee[n][l] / (Math.pow(n+1, 2.0) * Math.pow(l+1, 2.0)) ;
return val / Sum ;
}
/** F8 - Short Run High Gray Level Emphasis, SRHGLE.
* @return SRHGLE.*/
private double SRHGLE()
{
int n, l ;
double val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
for (l=0 ; l < largeur ; l++)
val += matriceajustee[n][l] * Math.pow(n+1, 2.0) / Math.pow(l+1, 2.0) ;
return val / Sum ;
}
/** F9 - Long Run Low Gray Level Emphasis, LRLGLE.
* @return LRLGLE.*/
private double LRLGLE()
{
int n, l ;
double val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
for (l=0 ; l < largeur ; l++)
val += matriceajustee[n][l] * Math.pow(l+1, 2.0) / Math.pow(n+1, 2.0) ;
return val / Sum ;
}
/** F10 - Long Run High Gray Level Emphasis, LRHGLE.
* @return LRHGLE.*/
private double LRHGLE()
{
int n, l ;
double val = 0.0 ;
for (n=0 ; n < nbNiveauxGris ; n++)
for (l=0 ; l < largeur ; l++)
val += matriceajustee[n][l] * Math.pow(n+1, 2.0) * Math.pow(l+1, 2.0) ;
return val / Sum ;
}
/* ---------------------------------------------------- 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] ;
}
} |
