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
|
package rdf.textures.glzm.glszm;
import java.util.Iterator;
import java.util.List;
import imageTiTi.Image;
import imageTiTi.reducer.ColorReducer;
import mathematics.Maths;
import measures.cclh.ConnectedComponentLabeling;
import measures.cclh.FifoCcl;
import morphee.Levelings.Leveling;
import processing.filters.Gaussian;
import utils.arrays.ArraysOperations;
/**
* <p>Description : Cette classe calcule la "Size Zone Matrix" pour une image (vignette).
* Il s'agit d'une creation de ma part.</p>
* <p>Packages necessaires : dv, imageTiTi, mathematics, measures, morphee, processing, utils.</p>
* <p>Copyright : Copyright (c) 2007.</p>
* <p>Laboratoires/Equipes : CMM (Mines-ParisTech), I&M (ex LXAO) LSIS.</p>
* <p>Dernieres modifications :<br>
* 11 Avril 2010, 1.3 => Gestion de la reduction des tailles pour le stockage dans la matrice.<br>
* <dd> => Possibilite de fixer la taille de la matrice ou de la laisser variable avec un pas.</dd><br>
* <dd> => Simplification par l'utilisation de l'interface ColorReducer.</dd><br>
* 26 Janvier 2010 => Modifications des methodes FindValues qui s'effectuent desormais en un seul passage.<br>
* 19 Janvier 2010 => Ajout de la methode "FillMatrix(DV, int, boolean)", pour le projet Loreal.<br>
* 29 Decembre 2009, 1.2 => Correction d'un bug pour la gestion de la valeur interdite :
* ccl.Label("this."image, 0, EightConnex, null).<br>
* <dd> => Ajout de la methode FillMatrix(Image, int, int) pour une generalisation dans GLZM.</dd><br>
* <dd> => Ajout de la methode FillMatrix(List) pour une generalisation dans GLZM.</dd><br>
* 27 Novembre 2009 => Correction d'un bug du a la gestion de la valeur interdite :
* Correspondances[i] = TrouverValeur(Carte, i)"-1" ;<br>
* 18 Avril 2008, 1.1 => Ajout de l'affinage des niveaux de gris par KMeans.<br>
* 10 Avril 2008 => Creation.</p>
*
* @author Guillaume THIBAULT
* @version 1.3
* <p>
* <!-- technical-bibtex-start -->
* BibTeX:
* <pre>
* @conference{Galloway75,
* address = {Minsk, Belarus},
* author = {Guillaume Thibault and Bernard Fertil and Claire Navarro and Sandrine Pereira and Pierre Cau
* and Nicolas Levy and Jean Sequeira and Jean-Luc Mari},
* booktitle = {Pattern Recognition and Information Processing (PRIP)},
* pages = {140--145},
* title = {{Texture Indexes and Gray Level Size Zone Matrix. Application to Cell Nuclei Classification},
* year = {2009}
* }
* </pre>
* <!-- technical-bibtex-end -->
</p>
*/
public class GrayLevelSizeZoneMatrix
{
/** Hauteur de la size zone matrix <=> Le nombre de niveaux de gris.*/
protected int nbGrayLevel = -1 ;
/** Nombre de tailles de zones a prendre en compte. Si FixedSize=true ce sera la largeur de la matrice, sinon c'est le pas.*/
protected int nbSizes = -1 ;
/** Largeur de la matrice. Si FixedSize Alors Width=nbSizes, Sinon Width=TailleZoneMax/nbSizes+1.*/
protected int Width = -1 ;
/** La largeur doit elle etre fixe ? */
protected boolean FixedSize = false ;
/** Tableau representant la size zone matrix.*/
protected double[][] matrix = null ;
/** L'image sur laquelle on a calcule la matrice de taille de zones, donc apres reduction du nombre de niveaux de gris.*/
protected Image Reduced = null ;
/** Volume sur lequel on a calcule la matrice de taille de zones, donc apres reduction du nombre de niveaux de gris.*/
protected DV Reduced3D = null ;
/** Classe qui va permettre le calcul/etiquettage des composantes connexes.*/
private ConnectedComponentLabeling ccl = new FifoCcl() ;
/** Un filtre gaussien, utile pour construire le marqueur du leveling.*/
private Gaussian gauss = new Gaussian(1, 1) ;
/** Un constructeur qui permet de modifier la taille de la Size Zone Matrix.
* @param nbGrayLevel Le nombre de niveaux de gris a prendre en compte, ce sera la hauteur de la matrice.
* @param nbSizes Nombre de tailles de zones a prendre en compte.
* Si FixedSize=true ce sera la largeur de la matrice, sinon c'est le pas.
* @param FixedSize La largeur doit elle etre fixe ? */
public GrayLevelSizeZoneMatrix(int nbGrayLevel, int nbSizes, boolean FixedSize)
{
if ( nbGrayLevel < 2 )
throw new IllegalArgumentException("Number of gray level incorrect: " + nbGrayLevel + ", wish [2...2^N[") ;
this.nbGrayLevel = nbGrayLevel ;
this.nbSizes = nbSizes ;
this.FixedSize = FixedSize ;
if ( !Maths.isPowerOf(nbGrayLevel, 2) )
throw new IllegalArgumentException("Number of gray level must be a power of 2: " + nbGrayLevel) ;
if ( FixedSize )
{
Width = nbSizes ;
matrix = new double[nbGrayLevel][Width] ;
}
}
/** Methode qui lance et gere les differentes etapes de calcul.
* @param image La vignette contenant la texture.
* @param reducer Classe qui permet de reduire le nombre de couleurs.
* @param leveling Methode de nivellement a utiliser avant la reduction des couleurs avec un filtre gaussien comme marqueur.
* Si ce parametre est null, alors rien n'est realise.
* @param ForbidenValue Valeur interdite (du fond) =>
* Valeur a ne pas prendre en compte pour les calculs. Si strictement negative, on prend toutes les valeurs en consideration.
* @param EightConnex Doit on travailler en huit connexite ?
* @param nbCPU Nombre de CPU autorises dans cette classes => Nombre de threads autorises.*/
public void FillMatrix(Image image, ColorReducer reducer, Leveling leveling, int ForbidenValue, boolean EightConnex, int nbCPU)
{
if ( !image.isGrayLevel() ) throw new IllegalArgumentException("Only gray level images supported.") ;
int i, width ;
Reduced = null ;
if ( leveling == null ) Reduced = reducer.Reduce(image, nbGrayLevel, ForbidenValue) ;
else Reduced = reducer.Reduce(leveling.Filter(image, nbCPU, gauss.Filter(image, nbCPU)), nbGrayLevel, ForbidenValue) ;
ccl.Label(Reduced, 0, EightConnex, null) ; // On calcule (étiquette) les composantes connexes.
int[][] Labels = ccl.Labels() ;
int[] Sizes = ccl.Sizes() ; // On récupère la dimension de chaque composante.
int[] Correspondances = new int[Sizes.length] ;
FindValues(Labels, Correspondances) ; // Correspondance composante/niveau de gris. La case 0 = ForbidenValue
width = 0 ;
for (i=1 ; i < Sizes.length ; i++) // On trouve la taille de la plus grande zone.
if ( Correspondances[i] >= 0 && width < Sizes[i] )
width = Sizes[i] ;
if ( FixedSize )
{
ArraysOperations.SetConstant(matrix, 0.0) ; // Matrice déjà allouée, donc il suffit de la re-initialiser.
for (i=1 ; i < Correspondances.length ; i++) // On remplit la matrice
if ( Correspondances[i] >= 0 )
matrix[Correspondances[i]][(int)((double)(Sizes[i]-1)/(double)width*(double)nbSizes)]++ ;
}
else
{
Width = width/nbSizes+1 ;
matrix = null ;
matrix = new double[nbGrayLevel][Width] ;
for (i=1 ; i < Correspondances.length ; i++) // On remplit la matrice
if ( Correspondances[i] >= 0 )
matrix[Correspondances[i]][Sizes[i]/nbSizes]++ ;
}
}
/** Methode qui lance et gere les differentes etapes de calcul.
* @param ImageReduced La vignette contenant la texture, dont les niveaux de gris ont prealablement ete reduit.
* @param Ccl La classe permettant de realiser l'etiquettage des composantes connexes,
* mais sur laquelle les calculs ont DEJA ete realises.*/
public void FillMatrix(Image ImageReduced, ConnectedComponentLabeling Ccl)
{
if ( !ImageReduced.isGrayLevel() ) throw new IllegalArgumentException("Only gray level images supported.") ;
int i, width ;
int[][] Labels = Ccl.Labels() ;
int[] Sizes = Ccl.Sizes() ;
int[] Correspondances = new int[Sizes.length] ;
FindValues(Labels, Correspondances) ; // Correspondance composante/niveau de gris. La case 0 = ForbidenValue
width = 0 ;
for (i=1 ; i < Sizes.length ; i++) // On trouve la taille max des composantes qui sera la largeur de la matrice.
if ( Correspondances[i] >= 0 && width < Sizes[i] )
width = Sizes[i] ;
if ( FixedSize )
{
ArraysOperations.SetConstant(matrix, 0.0) ; // Matrice déjà allouée, donc il suffit de la re-initialiser.
for (i=1 ; i < Correspondances.length ; i++) // On remplit la matrice
if ( Correspondances[i] >= 0 )
matrix[Correspondances[i]][(int)((double)(Sizes[i]-1)/(double)width*(double)nbSizes)]++ ;
}
else
{
Width = width/nbSizes+1 ;
matrix = null ;
matrix = new double[nbGrayLevel][Width] ;
for (i=1 ; i < Correspondances.length ; i++) // On remplit la matrice
if ( Correspondances[i] >= 0 )
matrix[Correspondances[i]][Sizes[i]/nbSizes]++ ;
}
}
/** Methode qui realise les calculs.
* @param list La liste contenant les images reduites.*/
public void FillMatrix(List<Image> list)
{
int i, x, y, Largeur, width, height, nb = 0 ;
Image shape = null ;
int[] Sizes = new int[list.size()] ;
Iterator<Image> iter = list.iterator() ;
Largeur = 0 ;
while ( iter.hasNext() )
{
shape = iter.next() ;
if ( !shape.isGrayLevel() ) throw new IllegalArgumentException("Only gray level image required.") ;
width = shape.Width() ;
height = shape.Height() ;
Sizes[nb] = 0 ; // Initialisation de la taille.
for (y=0 ; y < height ; y++)
for (x=0 ; x < width ; x++)
if ( shape.Pixel(y, x) > 0 ) Sizes[nb]++ ; // On compte les pixels de la zone.
if ( Largeur < Sizes[nb] ) Largeur = Sizes[nb] ;
shape = null ;
nb++ ;
}
if ( FixedSize )
{
ArraysOperations.SetConstant(matrix, 0.0) ; // Matrice déjà allouée, donc il suffit de la re-initialiser.
for (i=1 ; i < nb ; i++) // On remplit la matrice
matrix[FindColor(list.get(i))-1][(int)((double)(Sizes[i]-1)/(double)Largeur*(double)nbSizes)]++ ;
}
else
{
Width = Largeur/nbSizes + 1 ;
matrix = null ;
matrix = new double[nbGrayLevel][Width] ;
for (i=0 ; i < nb ; i++) // On remplit la matrice
matrix[FindColor(list.get(i))-1][Sizes[i]/nbSizes]++ ;
}
}
/** Methode qui permet de trouver la couleur de la vignette, car elle est codee avec des 0 et une autre couleur.
* @param image L'image dont on souhaite trouver la couleur.
* @return La valeur de la couleur trouvee.*/
private int FindColor(Image image)
{
for (int y=0 ; y < image.Height() ; y++)
for (int x=0 ; x < image.Width() ; x++)
if ( image.Pixel(y, x) > 0 )
return image.Pixel(y, x) ;
throw new Error("Color not found. This error must not occured.") ;
}
/** Une methode qui trouve la correspondance entre les composantes connexes et les niveaux de gris
* => Affecte la couleur reduite a chaque composante.
* @param Labels La carte des composantes.
* @param Correspondances Le tableau des correspondances, celui que l'on doit remplir.*/
private void FindValues(int[][] Labels, int[] Correspondances)
{
int hauteur = Labels.length ;
int largeur = Labels[0].length ;
for (int y=0 ; y < hauteur ; y++)
for (int x=0 ; x < largeur ; x++)
if ( Labels[y][x] > 0 )
Correspondances[Labels[y][x]] = Reduced.Pixel(y, x) - 1 ;
}
/** Une methode qui trouve la correspondance entre les composantes connexes et les niveaux de gris
* => Affecte la couleur reduite a chaque composante.
* @param Labels La carte des composantes.
* @param Correspondances Le tableau des correspondances, celui que l'on doit remplir.*/
private void FindValues(int[][][] Labels, int[] Correspondances)
{
int depth = Labels.length ;
int height = Labels[0].length ;
int width = Labels[0][0].length ;
for (int z=0 ; z < depth ; z++)
for (int y=0 ; y < height ; y++)
for (int x=0 ; x < width ; x++)
if ( Labels[z][y][x] > 0 )
Correspondances[Labels[z][y][x]] = Reduced3D.Voxel(z, y, x) - 1 ;
}
/* ----------------------------------------------------- Les getters ----------------------------------------------------- */
/** Methode qui retourne la matrice de taille de zone.
* @return La 'Size Zone Matrix'.*/
public double[][] getMatrix()
{
return matrix ;
}
public String toString()
{
StringBuffer sb = new StringBuffer() ;
for (int j=0 ; j < nbGrayLevel ; j++)
{
for (int i=0 ; i < nbSizes ; i++) sb.append(matrix[j][i] + " ") ;
sb.append("\n") ;
}
return sb.toString() ;
}
} |
[Image/Java] Gray Level Size Zone Matrix
ton poste tu dois marquer quand la bonne réponse tu as obtenu.
Répondre avec citation
Partager