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
|
package measures.histogram;
import java.util.List;
import imageTiTi.Image;
import imageTiTi.ImageBadTypeColorError;
import mathematics.Bresenham;
import mathematics.primitives.pointsTiTi.PointI;
import utils.arrays.ArraysOperations;
import utils.times.Chronometer;
/**
* <p>Description : Cette classe propose le calcul des differents histogrammes de projections (Integral Projection Function) d'une forme.
* Elle permet egalement de calculer la projection centrale (en anglais CPT pour Central Projection Transformation).</p>
* <p>Packages necessaires : diplays, imageTiTi, mathematics, utils.</p>
* <p>Dernieres modifications :<br>
* 07 Fevrier 2010, 1.3 => Mise a jour suite a la lecture de l'article ci-dessous. Gestion de differents types d'images.
* 14 Mai 2008, 1.2 => Mise a jour de la classe, notamment pour le calcul a repetition.<br>
* 21 aout 2007 => Creation.</p>
* <p>Copyright : Copyright (c) 2007.</p>
* <p>Laboratoires/Equipes : CMM (Mines-ParisTech), I&M (ex LXAO) LSIS.</p>
*
<!-- technical-bibtex-start -->
* BibTeX:
* <pre>
* @article{ZhouGeng04,
* author = {Zhi-Hua Zhou and Xin Geng},
* journal = {Pattern recognition},
* number = {5},
* pages = {1049-1056},
* title = {Projection Functions for Eye Detection},
* volume = {37},
* year = {2004}
* }
* </pre>
* <p/>
<!-- technical-bibtex-end -->
*
* @author Guillaume THIBAULT
* @version 1.3
*/
public class IntegralProjectionFunction
{
/** Premiere diagonale.*/
private int[] DiagonaleD = null ;
/** Deuxieme diagonale.*/
private int[] DiagonaleG = null ;
/** Projection horizontale.*/
private int[] Horizontale = null ;
/** Projection verticale.*/
private int[] Verticale = null ;
/** Premiere diagonale au format double.*/
private double[] DiagonaleD_Double = null ;
/** Deuxieme diagonale au format double.*/
private double[] DiagonaleG_Double = null ;
/** Projection horizontale au format double.*/
private double[] Horizontale_Double = null ;
/** Projection verticale au format double.*/
private double[] Verticale_Double = null ;
private Image Cpt = null ;
/** Un constructeur vide.*/
public IntegralProjectionFunction()
{
}
/** Methode qui permet d'allouer/initialiser les differents histogrammes en fonction de la taille de l'image contenante.
* @param largeur Largeur de l'image.
* @param hauteur Hauteur de l'image.*/
private void SetDimensions(int largeur, int hauteur)
{
if ( Horizontale == null || Horizontale.length != hauteur || Verticale.length != largeur ) // On évite de tout refaire.
{
DiagonaleD = null ;
DiagonaleD = new int[largeur+hauteur] ; // on alloue
DiagonaleG = null ;
DiagonaleG = new int[largeur+hauteur] ;
Horizontale = null ;
Horizontale = new int[hauteur] ;
Verticale = null ;
Verticale = new int[largeur] ;
DiagonaleD_Double = null ;
DiagonaleD_Double = new double[largeur+hauteur] ; // on alloue
DiagonaleG_Double = null ;
DiagonaleG_Double = new double[largeur+hauteur] ;
Horizontale_Double = null ;
Horizontale_Double = new double[hauteur] ;
Verticale_Double = null ;
Verticale_Double = new double[largeur] ;
}
ArraysOperations.SetConstant(Horizontale, 0) ;
ArraysOperations.SetConstant(Verticale, 0) ;
ArraysOperations.SetConstant(DiagonaleD, 0) ;
ArraysOperations.SetConstant(DiagonaleG, 0) ;
}
/** Methode qui lance le calcul des histogrammes.
* @param image Image contenant la forme.
* @param CalculerCpt Est ce que l'on doit calculer la CPT ?
* @param Chrono Le chronometre pour mesurer le temps d'execution.*/
public void Compute(Image image, boolean CalculerCpt, Chronometer Chrono) // Remplissage des Histogrammes
{
if ( Chrono != null )
{
System.out.print("Calcul des histogrammes de projections ") ;
if ( CalculerCpt ) System.out.print("et de la Central Projection Transformation : ") ;
else System.out.print(" : ") ;
Chrono.setMarqueur() ;
}
int y, x, p ;
int width = image.getWidth() ;
int height = image.getHeight() ;
SetDimensions(width, height) ;
switch ( image.getType() )
{
case Image.TYPE_BYTE_BINARY :
case Image.TYPE_BYTE_GRAY :
case Image.TYPE_USHORT_GRAY :
for (y=0 ; y < height ; y++)
for (x=0 ; x < width ; x++)
{ // On remplit les Histogrammes
p = image.Pixel(y, x) ;
DiagonaleG[y + x] += p ;
DiagonaleD[height-1-y + x] += p ;
Horizontale[y] += p ;
Verticale[x] += p ;
}
break ;
default : throw new ImageBadTypeColorError("Only gray level or binary image required.") ;
}
if ( CalculerCpt ) CPT(image) ;
for (x=0 ; x < width ; x++) Verticale_Double[x] = Verticale[x] / (double)height ;
for (y=0 ; y < height ; y++) Horizontale_Double[y] = Horizontale[y] / (double)width ;
p = width + height ;
for (x=0 ; x < p ; x++)
{
DiagonaleD_Double[x] = DiagonaleD[x] / (double)p ;
DiagonaleG_Double[x] = DiagonaleG[x] / (double)p ;
}
if ( Chrono != null ) System.out.println(Chrono.getTimeSinceMarqueurSecondes()) ;
}
/** Methode qui calcule la Central Projection Transformation.
* @param image L'image contenant la forme.*/
private void CPT(Image image)
{
boolean fin ;
int i, j, k, x, y ;
int largeur = image.getWidth() ;
int hauteur = image.getHeight() ;
int Bx, By, nb ;
List<PointI> Trajectoire ;
Bx = By = nb = 0 ;
Cpt = null ;
Cpt = new Image(largeur, hauteur, Image.TYPE_3BYTE_BGR) ;
for (i=0 ; i < hauteur ; i++) // On clone l'image et on calcule le barycentre
for (j=0 ; j < largeur ; j++)
if ( image.Pixel(i, j) > 0 )
{
Cpt.Pixel(i, j, image.Pixel(i, j)) ;
nb++ ;
Bx += j ;
By += i ;
}
Bx = (int)((double)Bx/(double)nb + 0.5) ;
By = (int)((double)By/(double)nb + 0.5) ;
fin = false ;
while ( !fin )
{
fin = true ;
for (i=0 ; i < hauteur ; i++)
for (j=0 ; j < largeur ; j++)
if ( Cpt.Pixel(i, j) > 0 ) // Si on rencontre un pixel
{
Trajectoire = null ;
Trajectoire = Bresenham.TracerListe(j, i, Bx, By) ;
k = Trajectoire.size() - 1 ;
while ( k >= 0 ) // on part du barycentre jusqu'à rencontrer un pixel vide
{
x = Trajectoire.get(k).getX() ;
y = Trajectoire.get(k).getY() ;
if ( Cpt.Pixel(y, x) == 0 )
{
Cpt.Pixel(y, x, Cpt.Pixel(i, j)) ;
Cpt.Pixel(i, j, 0) ;
k = -1 ;
fin = false ;
}
k-- ;
}
}
}
}
/* ----------------------------------------------------------- Les getters ----------------------------------------------------------- */
/** Methode qui retourne le resultat de la Cpt.
* @return L'image contenant le resultat de la Cpt.*/
public Image getCpt()
{
return Cpt ;
}
/** Methode qui renvoit le resultat de la projection sur la diagonale droite.
* @return La projection sur la diagonale droite.*/
public int[] getDiagonaleD()
{
return DiagonaleD ;
}
/** Methode qui renvoit le resultat de la projection sur la diagonale gauche.
* @return La projection sur la diagonale gauche.*/
public int[] getDiagonaleG()
{
return DiagonaleG ;
}
/** Methode qui renvoit le resultat de la projection horizontale.
* @return La projection a l'horizontale.*/
public int[] getHorizontale()
{
return Horizontale ;
}
/** Methode qui renvoit le resultat de la projection verticale.
* @return La projection verticale.*/
public int[] getVerticale()
{
return Verticale ;
}
/** Methode qui renvoit le resultat de la projection sur la diagonale droite au format double et avec calcul de la moyenne.
* @return La projection sur la diagonale droite.*/
public double[] DiagonaleD()
{
return DiagonaleD_Double ;
}
/** Methode qui renvoit le resultat de la projection sur la diagonale gauche au format double et avec calcul de la moyenne.
* @return La projection sur la diagonale gauche.*/
public double[] DiagonaleG()
{
return DiagonaleG_Double ;
}
/** Methode qui renvoit le resultat de la projection horizontale au format double et avec calcul de la moyenne.
* @return La projection a l'horizontale.*/
public double[] Horizontale()
{
return Horizontale_Double ;
}
/** Methode qui renvoit le resultat de la projection verticale au format double et avec calcul de la moyenne.
* @return La projection verticale.*/
public double[] Verticale()
{
return Verticale_Double ;
}
} |
