[Image/Java] Histogrammes de projections, Intégrales/Variance de fonctions de projections

**ToTo13** · 09/02/2010, 17h43

Bonjour,

voici trois classes permettant de calculer des caractéristiques globales de formes à partir de :

Integral Projection Function (histogrammes de projections).
Variance Projection Function
Generalized Projection Function

C'est une version améliorée de cette contribution.

Voici un lien vers l'article cité dans les classes et ayant servi à les développer.

Afin de rendre ces méthodes plus robustes, il est souvent conseillé de faire une rotation suivant l'axe principal puis une transformation d'échelle.

**ToTo13** · 09/02/2010, 17h46

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
 
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 ;
	}
 
 
}

**ToTo13** · 09/02/2010, 17h48

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
 
import imageTiTi.Image;
import imageTiTi.ImageBadTypeColorError;
import utils.arrays.ArraysOperations;
import utils.times.Chronometer;
 
/**
 * <p>Description : Cette classe propose le calcul de la variance des histogrammes de projections (Variance Projection Function) d'une forme.</p>
 * <p>Packages necessaires : imageTiTi, utils.</p>
 * <p>Dernieres modifications :<br>
 * 07 Fevrier 2010 => 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.0
 */
 
public class VarianceProjectionFunction
{
 
/** Premiere diagonale.*/
private double[] DiagonaleD = null ;
/** Deuxieme diagonale.*/
private double[] DiagonaleG = null ;
/** Projection horizontale.*/
private double[] Horizontale = null ;
/** Projection verticale.*/
private double[] Verticale = null ;
 
/** Classe permettant de calculer l'integrale de la projection de la function. Necessaire pour le calcul de la variance de la projection.*/
public IntegralProjectionFunction ipf = new IntegralProjectionFunction() ;
 
 
 
 
 
/** Un constructeur vide.*/
public VarianceProjectionFunction()
	{
	}
 
 
 
/** 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 double[largeur+hauteur] ; // on alloue
		DiagonaleG = null ;
		DiagonaleG = new double[largeur+hauteur] ;
		Horizontale = null ;
		Horizontale = new double[hauteur] ;
		Verticale = null ;
		Verticale = new double[largeur] ;
 
		}
 
	ArraysOperations.SetConstant(Horizontale, 0.0) ;
	ArraysOperations.SetConstant(Verticale, 0.0) ;
	ArraysOperations.SetConstant(DiagonaleD, 0.0) ;
	ArraysOperations.SetConstant(DiagonaleG, 0.0) ;
	}
 
 
 
/** Methode qui lance le calcul des histogrammes des variances.
 * @param image Image contenant la forme.
 * @param Chrono Le chronometre pour mesurer le temps d'execution.*/
public void Compute(Image image, Chronometer Chrono) // Remplissage des Histogrammes
	{
	if ( Chrono != null )
		{
		System.out.print("Calcul des variances de projections : ") ;
		Chrono.setMarqueur() ;
		}
 
	int y, x, p ;
	int width = image.getWidth() ;
	int height = image.getHeight() ;
 
	SetDimensions(width, height) ;
 
	ipf.Compute(image, false, null) ; // On commence par calculer l'intégrale de la fonction de projection.
	double[] DD = ipf.DiagonaleD() ;
	double[] DG = ipf.DiagonaleG() ;
	double[] H = ipf.Horizontale() ;
	double[] V = ipf.Verticale() ;
 
	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] += Math.pow((double)p - DG[y+x], 2.0) ;
					DiagonaleD[height-1-y + x] += Math.pow((double)p - DD[height-1-y + x], 2.0) ;
					Horizontale[y] += Math.pow((double)p - H[y], 2.0) ;
					Verticale[x] += Math.pow((double)p - V[x], 2.0) ;
					}
			break ;
		default : throw new ImageBadTypeColorError("Only gray level or binary image required.") ;
		}
 
	for (x=0 ; x < width ; x++) Verticale[x] /= (double)height ;
	for (y=0 ; y < height ; y++) Horizontale[y] /= (double)width ;
	p = width + height ;
	for (x=0 ; x < p ; x++)
		{
		DiagonaleD[x] /= (double)p ;
		DiagonaleG[x] /=(double)p ;
		}
 
	if ( Chrono != null ) System.out.println(Chrono.getTimeSinceMarqueurSecondes()) ;
	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* ----------------------------------------------------------- Les getters ----------------------------------------------------------- */
/** Methode qui renvoit le resultat de la projection sur la diagonale droite.
 * @return La projection sur la diagonale droite.*/
public double[] DiagonaleD()
	{
	return DiagonaleD ;
	}
 
/** Methode qui renvoit le resultat de la projection sur la diagonale gauche.
 * @return La projection sur la diagonale gauche.*/
public double[] DiagonaleG()
	{
	return DiagonaleG ;
	}
 
/** Methode qui renvoit le resultat de la projection horizontale.
 * @return La projection a l'horizontale.*/
public double[] Horizontale()
	{
	return Horizontale ;
	}
 
/** Methode qui renvoit le resultat de la projection verticale.
 * @return La projection verticale.*/
public double[] Verticale()
	{
	return Verticale ;
	}
 
 
 
}

**ToTo13** · 09/02/2010, 17h50

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
 
package measures.histogram;
 
import imageTiTi.Image;
import utils.arrays.ArraysOperations;
import utils.times.Chronometer;
 
/**
 * <p>Description : Cette classe propose le calcul des fonctions de projections generalisees (Generalized Projection Function) d'une forme.</p>
 * <p>Packages necessaires : imageTiTi, utils.</p>
 * <p>Dernieres modifications :<br>
 * 07 Fevrier 2010 => 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.0
 */
 
public class GeneralizedFunctionProjection
{
 
/** Premiere diagonale.*/
private double[] DiagonaleD = null ;
/** Deuxieme diagonale.*/
private double[] DiagonaleG = null ;
/** Projection horizontale.*/
private double[] Horizontale = null ;
/** Projection verticale.*/
private double[] Verticale = null ;
 
 
 
/** Classe permettant de calculer l'integrale de la projection de la function.*/
public IntegralProjectionFunction ipf = new IntegralProjectionFunction() ;
/** Classe permettant de calculer la variance de la projection de la function.*/
public VarianceProjectionFunction vpf = new VarianceProjectionFunction() ;
 
 
 
 
/** Un constructeur vide.*/
public GeneralizedFunctionProjection()
	{
	}
 
 
 
/** 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 double[largeur+hauteur] ; // on alloue
		DiagonaleG = null ;
		DiagonaleG = new double[largeur+hauteur] ;
		Horizontale = null ;
		Horizontale = new double[hauteur] ;
		Verticale = null ;
		Verticale = new double[largeur] ;
 
		}
 
	ArraysOperations.SetConstant(Horizontale, 0.0) ;
	ArraysOperations.SetConstant(Verticale, 0.0) ;
	ArraysOperations.SetConstant(DiagonaleD, 0.0) ;
	ArraysOperations.SetConstant(DiagonaleG, 0.0) ;
	}
 
 
 
 
 
 
/** Methode qui lance le calcul des histogrammes des variances : (1-Alpha) * IPF + Alpha * VPF 
 * @param image Image contenant la forme.
 * @param alpha Coefficient (dans [0..1]) de fusion des fonctions Integrale et Variance.
 * @param Chrono Le chronometre pour mesurer le temps d'execution.*/
public void Compute(Image image, double alpha, Chronometer Chrono) // Remplissage des Histogrammes
	{
	if ( Chrono != null )
		{
		System.out.print("Calcul de la fonction de projections généralisée : ") ;
		Chrono.setMarqueur() ;
		}
 
	int y, x, p ;
	int width = image.getWidth() ;
	int height = image.getHeight() ;
 
	SetDimensions(width, height) ;
 
	ipf.Compute(image, false, null) ; // On commence par calculer l'intégrale de la fonction de projection.
	vpf.Compute(image, null) ; // Puis par calculer la variance de la fonction de projection.
 
	double[] DD = ipf.DiagonaleD() ;
	double[] DG = ipf.DiagonaleG() ;
	double[] H = ipf.Horizontale() ;
	double[] V = ipf.Verticale() ;
 
	double[] vDD = vpf.DiagonaleD() ;
	double[] vDG = vpf.DiagonaleG() ;
	double[] vH = vpf.Horizontale() ;
	double[] vV = vpf.Verticale() ;
 
	for (x=0 ; x < width ; x++) Verticale[x] = (1.0-alpha)*V[x] + alpha*vV[x] ;
	for (y=0 ; y < height ; y++) Horizontale[y] = (1.0-alpha)*H[x] + alpha*vH[x] ;
	p = width + height ;
	for (x=0 ; x < p ; x++)
		{
		DiagonaleD[x] = (1.0-alpha)*DD[x] + alpha*vDD[x] ;
		DiagonaleG[x] = (1.0-alpha)*DG[x] + alpha*vDG[x] ;
		}
 
	if ( Chrono != null ) System.out.println(Chrono.getTimeSinceMarqueurSecondes()) ;
	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/* ----------------------------------------------------------- Les getters ----------------------------------------------------------- */
/** Methode qui renvoit le resultat de la projection sur la diagonale droite.
 * @return La projection sur la diagonale droite.*/
public double[] DiagonaleD()
	{
	return DiagonaleD ;
	}
 
/** Methode qui renvoit le resultat de la projection sur la diagonale gauche.
 * @return La projection sur la diagonale gauche.*/
public double[] DiagonaleG()
	{
	return DiagonaleG ;
	}
 
/** Methode qui renvoit le resultat de la projection horizontale.
 * @return La projection a l'horizontale.*/
public double[] Horizontale()
	{
	return Horizontale ;
	}
 
/** Methode qui renvoit le resultat de la projection verticale.
 * @return La projection verticale.*/
public double[] Verticale()
	{
	return Verticale ;
	}
 
 
 
}

[Image/Java] Histogrammes de projections, Intégrales/Variance de fonctions de projections

Contribuez

Discussions similaires

Partager

Partager