1 | //////////////////////////////// |
---|
2 | // Classe Alignement // |
---|
3 | // Franck RICHARD // |
---|
4 | // franckrichard033@gmail.com // |
---|
5 | // BAORadio // |
---|
6 | // février 2011 // |
---|
7 | //////////////////////////////// |
---|
8 | |
---|
9 | |
---|
10 | #include "alignement.h" |
---|
11 | |
---|
12 | |
---|
13 | /************************************************************************************** |
---|
14 | ** Constructeur de la classe Alignement |
---|
15 | ** |
---|
16 | ***************************************************************************************/ |
---|
17 | |
---|
18 | Alignement::Alignement() |
---|
19 | { |
---|
20 | //Initialisation des paramÚtres des antennes |
---|
21 | |
---|
22 | InitAlignement(); |
---|
23 | } |
---|
24 | |
---|
25 | |
---|
26 | /************************************************************************************** |
---|
27 | ** Destructeur de la classe Alignement |
---|
28 | ** |
---|
29 | ***************************************************************************************/ |
---|
30 | |
---|
31 | Alignement::~Alignement() |
---|
32 | { |
---|
33 | } |
---|
34 | |
---|
35 | |
---|
36 | /************************************************************************************** |
---|
37 | ** Initialisations des vecteurs et des paramÚtres d'alignement |
---|
38 | ** |
---|
39 | ***************************************************************************************/ |
---|
40 | |
---|
41 | void Alignement::InitAlignement() |
---|
42 | { |
---|
43 | // On initialise les points de correction |
---|
44 | |
---|
45 | for (int i=0; i< MAXALIGNEMENTANTENNE; i++) |
---|
46 | { |
---|
47 | ad[i] = 0.0; |
---|
48 | de[i] = 0.0; |
---|
49 | delta_ad[i] = 0; |
---|
50 | delta_de[i] = 0; |
---|
51 | tsl[i] = 0.0; |
---|
52 | } |
---|
53 | |
---|
54 | // initialisation de la matrice de rotation (à la matrice identité) |
---|
55 | |
---|
56 | Identity(); |
---|
57 | |
---|
58 | |
---|
59 | // initialisation de la direction en azimut de l'étoile polaire |
---|
60 | |
---|
61 | delta_az_polar = 0; |
---|
62 | |
---|
63 | // Nbre de points (de mesures) actuellement disponibles pour |
---|
64 | // bâtir les matrices de correction |
---|
65 | |
---|
66 | nbrcorrections = 0; |
---|
67 | |
---|
68 | // Est-ce que l'antenne est en cours d'alignement ? |
---|
69 | |
---|
70 | AlignementEnCours = 0; |
---|
71 | |
---|
72 | // La matrice de correction a-t-elle été calculée ? |
---|
73 | |
---|
74 | Matrice_ok = false; |
---|
75 | |
---|
76 | // Méthode d'alignement par défaut |
---|
77 | |
---|
78 | MethodeAlignement = SIMPLE; |
---|
79 | } |
---|
80 | |
---|
81 | |
---|
82 | |
---|
83 | /************************************************************************************** |
---|
84 | ** Initialisation des paramÚtres de la classe astro |
---|
85 | ** |
---|
86 | ***************************************************************************************/ |
---|
87 | |
---|
88 | void Alignement::TransmettreParametresClasseAstro(double Annee, double Mois, double Jour, double Heu, double Min, double Sec, double Longitude, double Latitude, double Pression, double Temp) |
---|
89 | { |
---|
90 | DefinirLongitudeLatitude(Longitude, Latitude); |
---|
91 | DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec); |
---|
92 | DefinirPressionTemp(Pression, Temp); |
---|
93 | } |
---|
94 | |
---|
95 | |
---|
96 | /************************************************************************************** |
---|
97 | ** 1 0 0 |
---|
98 | ** 0 1 0 |
---|
99 | ** 0 0 1 |
---|
100 | ***************************************************************************************/ |
---|
101 | |
---|
102 | void Alignement::Identity() |
---|
103 | { |
---|
104 | MATRICE[1][1] = 1.0; |
---|
105 | MATRICE[2][1] = 0.0; |
---|
106 | MATRICE[3][1] = 0.0; |
---|
107 | |
---|
108 | MATRICE[1][2] = 0.0; |
---|
109 | MATRICE[2][2] = 1.0; |
---|
110 | MATRICE[3][2] = 0.0; |
---|
111 | |
---|
112 | MATRICE[1][3] = 0.0; |
---|
113 | MATRICE[2][3] = 0.0; |
---|
114 | MATRICE[3][3] = 1.0; |
---|
115 | } |
---|
116 | |
---|
117 | |
---|
118 | |
---|
119 | /************************************************************************************** |
---|
120 | ** Calcule la matrice de rotation d'un angle alpha autour d'un axe défini |
---|
121 | ** par les paramÚtres t et r dans un systÚme de coordonnées spĥériques |
---|
122 | ** Le signe - devant le cos permet seulement de rendre le repÚre compatible avec WinStars |
---|
123 | ** que j'utilise pour faire des vérifications... |
---|
124 | ** Fonction utile pour de débogage de la fct d'alignement |
---|
125 | ** |
---|
126 | ***************************************************************************************/ |
---|
127 | |
---|
128 | void Alignement::RotationAutourDunAxe(double t, double r, double alpha) |
---|
129 | { |
---|
130 | double x = -cos(t) * cos(r); |
---|
131 | double y = sin(t) * cos(r); |
---|
132 | double z = sin(r); |
---|
133 | |
---|
134 | double c = cos(alpha); |
---|
135 | double s = sin(alpha); |
---|
136 | |
---|
137 | |
---|
138 | MATRICE[1][1] = x * x + (1.0 - x * x) * c; |
---|
139 | MATRICE[1][2] = x * y * (1.0 - c) - z * s; |
---|
140 | MATRICE[1][3] = x * z * (1.0 - c) + y * s; |
---|
141 | |
---|
142 | MATRICE[2][1] = x * y * (1.0 - c) + z * s; |
---|
143 | MATRICE[2][2] = y * y + (1.0 - y * y) * c; |
---|
144 | MATRICE[2][3] = y * z * (1.0 - c) - x * s; |
---|
145 | |
---|
146 | MATRICE[3][1] = x * z * (1.0 - c) - y * s; |
---|
147 | MATRICE[3][2] = y * z * (1.0 - c) + x * s; |
---|
148 | MATRICE[3][3] = z * z + (1.0 - z * z) * c; |
---|
149 | } |
---|
150 | |
---|
151 | |
---|
152 | /************************************************************************************** |
---|
153 | ** Matrice intermédiaire nécessaire au calcul de la matrice de correction |
---|
154 | ** dans le mode d'alignement TAKI |
---|
155 | ** Consultez la documentation pour comprendre le principe de la correction AFFINE/TAKI |
---|
156 | ** |
---|
157 | ***************************************************************************************/ |
---|
158 | |
---|
159 | void Alignement::Calculer_Matrice_LMN(Coord p1, Coord p2, Coord p3) |
---|
160 | { |
---|
161 | double temp[4][4]; |
---|
162 | double UnitVect[4][4]; |
---|
163 | |
---|
164 | temp[1][1] = p2.x - p1.x; |
---|
165 | temp[2][1] = p3.x - p1.x; |
---|
166 | |
---|
167 | temp[1][2] = p2.y - p1.y; |
---|
168 | temp[2][2] = p3.y - p1.y; |
---|
169 | |
---|
170 | temp[1][3] = p2.z - p1.z; |
---|
171 | temp[2][3] = p3.z - p1.z; |
---|
172 | |
---|
173 | UnitVect[1][1] = (temp[1][2] * temp[2][3]) - (temp[1][3] * temp[2][2]); |
---|
174 | UnitVect[1][2] = (temp[1][3] * temp[2][1]) - (temp[1][1] * temp[2][3]); |
---|
175 | UnitVect[1][3] = (temp[1][1] * temp[2][2]) - (temp[1][2] * temp[2][1]); |
---|
176 | UnitVect[2][1] = pow(UnitVect[1][1], 2.0) + pow(UnitVect[1][2], 2.0) + pow (UnitVect[1][3], 2.0); |
---|
177 | UnitVect[2][2] = sqrt(UnitVect[2][1]); |
---|
178 | if (UnitVect[2][2] != 0.0) UnitVect[2][3] = 1.0 / UnitVect[2][2]; |
---|
179 | |
---|
180 | for (char i=1; i<=2; i++) for (char j=1; j<=3; j++) GETLMN[i][j] = temp[i][j]; |
---|
181 | |
---|
182 | GETLMN[3][1] = UnitVect[2][3] * UnitVect[1][1]; |
---|
183 | GETLMN[3][2] = UnitVect[2][3] * UnitVect[1][2]; |
---|
184 | GETLMN[3][3] = UnitVect[2][3] * UnitVect[1][3]; |
---|
185 | } |
---|
186 | |
---|
187 | |
---|
188 | |
---|
189 | /************************************************************************************** |
---|
190 | ** Calcul de la matrice de correction dans le mode d'alignement TAKI |
---|
191 | ** |
---|
192 | ***************************************************************************************/ |
---|
193 | |
---|
194 | int Alignement::Calculer_Matrice_Taki(double x, double y, Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3) |
---|
195 | { |
---|
196 | double Det; |
---|
197 | double EQLMN1[4][4]; |
---|
198 | double EQLMN2[4][4]; |
---|
199 | double EQMI_T[4][4]; |
---|
200 | |
---|
201 | //construit les matrices EQLMN1 & 2 |
---|
202 | |
---|
203 | Calculer_Matrice_LMN(a1, a2, a3); |
---|
204 | |
---|
205 | for (char i=1; i<=3; i++) for (char j=1; j<=3; j++) EQLMN1[i][j]=GETLMN[i][j]; |
---|
206 | |
---|
207 | Calculer_Matrice_LMN(m1, m2, m3); |
---|
208 | |
---|
209 | for (char i=1; i<=3; i++) for (char j=1; j<=3; j++) EQLMN2[i][j]=GETLMN[i][j]; |
---|
210 | |
---|
211 | // Calcule le déterminant de EQLMN1 |
---|
212 | |
---|
213 | Det = EQLMN1[1][1] * ((EQLMN1[2][2] * EQLMN1[3][3]) - (EQLMN1[3][2] * EQLMN1[2][ 3])); |
---|
214 | Det = Det - (EQLMN1[1][2] * ((EQLMN1[2][1] * EQLMN1[3][3]) - (EQLMN1[3][1] * EQLMN1[2][3]))); |
---|
215 | Det = Det + (EQLMN1[1][3] * ((EQLMN1[2][1] * EQLMN1[3][2]) - (EQLMN1[3][1] * EQLMN1[2][2]))); |
---|
216 | |
---|
217 | |
---|
218 | // Calcule la matrice inverse EQMI_T de EQLMN1 |
---|
219 | |
---|
220 | if (Det == 0.0) |
---|
221 | { |
---|
222 | ErreurLog("Erreur Matrice_Taki. Impossible de calculer l'inverse de la matrice avec un determinant = 0 \n"); |
---|
223 | return 0; |
---|
224 | } |
---|
225 | else |
---|
226 | { |
---|
227 | EQMI_T[1][1] = ((EQLMN1[2][2] * EQLMN1[3][3]) - (EQLMN1[3][2] * EQLMN1[2][3])) / Det; |
---|
228 | EQMI_T[1][2] = ((EQLMN1[1][3] * EQLMN1[3][2]) - (EQLMN1[1][2] * EQLMN1[3][3])) / Det; |
---|
229 | EQMI_T[1][3] = ((EQLMN1[1][2] * EQLMN1[2][3]) - (EQLMN1[2][2] * EQLMN1[1][3])) / Det; |
---|
230 | EQMI_T[2][1] = ((EQLMN1[2][3] * EQLMN1[3][1]) - (EQLMN1[3][3] * EQLMN1[2][1])) / Det; |
---|
231 | EQMI_T[2][2] = ((EQLMN1[1][1] * EQLMN1[3][3]) - (EQLMN1[3][1] * EQLMN1[1][3])) / Det; |
---|
232 | EQMI_T[2][3] = ((EQLMN1[1][3] * EQLMN1[2][1]) - (EQLMN1[2][3] * EQLMN1[1][1])) / Det; |
---|
233 | EQMI_T[3][1] = ((EQLMN1[2][1] * EQLMN1[3][2]) - (EQLMN1[3][1] * EQLMN1[2][2])) / Det; |
---|
234 | EQMI_T[3][2] = ((EQLMN1[1][2] * EQLMN1[3][1]) - (EQLMN1[3][2] * EQLMN1[1][1])) / Det; |
---|
235 | EQMI_T[3][3] = ((EQLMN1[1][1] * EQLMN1[2][2]) - (EQLMN1[2][1] * EQLMN1[1][2])) / Det; |
---|
236 | } |
---|
237 | |
---|
238 | |
---|
239 | // Effectue le produit des matrices EQMI_T et EQLMN2 |
---|
240 | |
---|
241 | MATRICE[1][1] = (EQMI_T[1][1] * EQLMN2[1][1]) + (EQMI_T[1][2] * EQLMN2[2][1]) + (EQMI_T[1][3] * EQLMN2[3][1]); |
---|
242 | MATRICE[1][2] = (EQMI_T[1][1] * EQLMN2[1][2]) + (EQMI_T[1][2] * EQLMN2[2][2]) + (EQMI_T[1][3] * EQLMN2[3][2]); |
---|
243 | MATRICE[1][3] = (EQMI_T[1][1] * EQLMN2[1][3]) + (EQMI_T[1][2] * EQLMN2[2][3]) + (EQMI_T[1][3] * EQLMN2[3][3]); |
---|
244 | |
---|
245 | MATRICE[2][1] = (EQMI_T[2][1] * EQLMN2[1][1]) + (EQMI_T[2][2] * EQLMN2[2][1]) + (EQMI_T[2][3] * EQLMN2[3][1]); |
---|
246 | MATRICE[2][2] = (EQMI_T[2][1] * EQLMN2[1][2]) + (EQMI_T[2][2] * EQLMN2[2][2]) + (EQMI_T[2][3] * EQLMN2[3][2]); |
---|
247 | MATRICE[2][3] = (EQMI_T[2][1] * EQLMN2[1][3]) + (EQMI_T[2][2] * EQLMN2[2][3]) + (EQMI_T[2][3] * EQLMN2[3][3]); |
---|
248 | |
---|
249 | MATRICE[3][1] = (EQMI_T[3][1] * EQLMN2[1][1]) + (EQMI_T[3][2] * EQLMN2[2][1]) + (EQMI_T[3][3] * EQLMN2[3][1]); |
---|
250 | MATRICE[3][2] = (EQMI_T[3][1] * EQLMN2[1][2]) + (EQMI_T[3][2] * EQLMN2[2][2]) + (EQMI_T[3][3] * EQLMN2[3][2]); |
---|
251 | MATRICE[3][3] = (EQMI_T[3][1] * EQLMN2[1][3]) + (EQMI_T[3][2] * EQLMN2[2][3]) + (EQMI_T[3][3] * EQLMN2[3][3]); |
---|
252 | |
---|
253 | |
---|
254 | // Calcule l'offset sur le ciel |
---|
255 | |
---|
256 | VECT_OFFSET.x = m1.x - ((a1.x * MATRICE[1][1]) + (a1.y * MATRICE[2][1]) + (a1.z * MATRICE[3][1])); |
---|
257 | VECT_OFFSET.y = m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2]) + (a1.z * MATRICE[3][2])); |
---|
258 | VECT_OFFSET.z = m1.z - ((a1.x * MATRICE[1][3]) + (a1.y * MATRICE[2][3]) + (a1.z * MATRICE[3][3])); |
---|
259 | |
---|
260 | |
---|
261 | |
---|
262 | if (x + y == 0 ) |
---|
263 | { |
---|
264 | return 0; |
---|
265 | } |
---|
266 | else |
---|
267 | { |
---|
268 | return PointSitueDansSurfaceTriangle(x, y, a1.x, a1.y, a2.x, a2.y, a3.x, a3.y); |
---|
269 | } |
---|
270 | } |
---|
271 | |
---|
272 | |
---|
273 | void Alignement::AppliquerMatriceCorrectionTaki(Coord * result, Coord vect) |
---|
274 | { |
---|
275 | // Applique la correction sur le vecteur orientation vect avec |
---|
276 | // vect.x = ascension droite |
---|
277 | // vect.y = déclinaison |
---|
278 | // vect.z = 1 |
---|
279 | |
---|
280 | result->x = VECT_OFFSET.x + ((vect.x * MATRICE[1][1]) + (vect.y * MATRICE[2][1]) + (vect.z * MATRICE[3][1])); |
---|
281 | result->y = VECT_OFFSET.y + ((vect.x * MATRICE[1][2]) + (vect.y * MATRICE[2][2]) + (vect.z * MATRICE[3][2])); |
---|
282 | result->z = VECT_OFFSET.z + ((vect.x * MATRICE[1][3]) + (vect.y * MATRICE[2][3]) + (vect.z * MATRICE[3][3])); |
---|
283 | } |
---|
284 | |
---|
285 | |
---|
286 | |
---|
287 | |
---|
288 | /************************************************************************************** |
---|
289 | ** Matrice intermédiaire nécessaire au calcul de la matrice de correction |
---|
290 | ** dans le mode d'alignement AFFINE |
---|
291 | ** |
---|
292 | ***************************************************************************************/ |
---|
293 | |
---|
294 | void Alignement::Calculer_Matrice_GETPQ(Coord p1, Coord p2, Coord p3) |
---|
295 | { |
---|
296 | GETPQ[1][1] = p2.x - p1.x; |
---|
297 | GETPQ[2][1] = p3.x - p1.x; |
---|
298 | GETPQ[1][2] = p2.y - p1.y; |
---|
299 | GETPQ[2][2] = p3.y - p1.y; |
---|
300 | } |
---|
301 | |
---|
302 | |
---|
303 | |
---|
304 | /************************************************************************************** |
---|
305 | ** Calcul de la matrice de correction dans le mode d'alignement AFFINE |
---|
306 | ** |
---|
307 | ***************************************************************************************/ |
---|
308 | |
---|
309 | int Alignement::Calculer_Matrice_Affine( double x, double y, Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3) |
---|
310 | { |
---|
311 | double Det; |
---|
312 | double EQMI[4][4]; |
---|
313 | double EQMP[4][4]; |
---|
314 | double EQMQ[4][4]; |
---|
315 | |
---|
316 | //Construit les matrices EQMP et EQMQ |
---|
317 | |
---|
318 | Calculer_Matrice_GETPQ(a1, a2, a3); |
---|
319 | |
---|
320 | for (char i=1; i<=3; i++) for (char j=1; j<=3; j++) EQMP[i][j]=GETPQ[i][j]; |
---|
321 | |
---|
322 | Calculer_Matrice_GETPQ(m1, m2, m3); |
---|
323 | |
---|
324 | for (char i=1; i<=3; i++) for (char j=1; j<=3; j++) EQMQ[i][j]=GETPQ[i][j]; |
---|
325 | |
---|
326 | // Calcule l'inverse de EQMP |
---|
327 | |
---|
328 | Det = (EQMP[1][1] * EQMP[2][2]) - (EQMP[1][2] * EQMP[2][1]); |
---|
329 | |
---|
330 | if (Det == 0) |
---|
331 | { |
---|
332 | ErreurLog("Erreur Matrice_Affine. Impossible de calculer l'inverse de la matrice avec un determinant = 0 \n"); |
---|
333 | return 0; |
---|
334 | } |
---|
335 | else |
---|
336 | { |
---|
337 | // Si le déterminant n'est pas nul |
---|
338 | EQMI[1][1] = EQMP[2][2] / Det; |
---|
339 | EQMI[1][2] = -EQMP[1][2] / Det; |
---|
340 | EQMI[2][1] = -EQMP[2][1] / Det; |
---|
341 | EQMI[2][2] = EQMP[1][1] / Det; |
---|
342 | } |
---|
343 | |
---|
344 | |
---|
345 | // MATRICE = EQMI * EQMQ |
---|
346 | |
---|
347 | MATRICE[1][1] = (EQMI[1][1] * EQMQ[1][1]) + (EQMI[1][2] * EQMQ[2][1]); |
---|
348 | MATRICE[1][2] = (EQMI[1][1] * EQMQ[1][2]) + (EQMI[1][2] * EQMQ[2][2]); |
---|
349 | MATRICE[2][1] = (EQMI[2][1] * EQMQ[1][1]) + (EQMI[2][2] * EQMQ[2][1]); |
---|
350 | MATRICE[2][2] = (EQMI[2][1] * EQMQ[1][2]) + (EQMI[2][2] * EQMQ[2][2]); |
---|
351 | |
---|
352 | // Calcul du vecteur offset sur le ciel |
---|
353 | |
---|
354 | VECT_OFFSET.x = m1.x - ((a1.x * MATRICE[1][1]) + (a1.y * MATRICE[2][1])); |
---|
355 | VECT_OFFSET.y = m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2])); |
---|
356 | |
---|
357 | return 1; |
---|
358 | } |
---|
359 | |
---|
360 | |
---|
361 | |
---|
362 | /************************************************************************************** |
---|
363 | ** Calcule la quantité CoordObjets * MATRICECorrection + VECT_offset |
---|
364 | ** |
---|
365 | ***************************************************************************************/ |
---|
366 | |
---|
367 | void Alignement::AppliquerMatriceCorrectionAffine( Coord * result, Coord ob) |
---|
368 | { |
---|
369 | result->x = VECT_OFFSET.x + ((ob.x * MATRICE[1][1]) + (ob.y * MATRICE[2][1])); |
---|
370 | result->y = VECT_OFFSET.y + ((ob.x * MATRICE[1][2]) + (ob.y * MATRICE[2][2])); |
---|
371 | } |
---|
372 | |
---|
373 | |
---|
374 | |
---|
375 | /************************************************************************************** |
---|
376 | ** Calcule la matrice de correction issue de la procédure d'alignement des antennes |
---|
377 | ** |
---|
378 | ** Cette méthode qui utilise trois points de correction seulement est particuliÚrement |
---|
379 | ** simple mais repose sur la qualité des pointages effectués lors de l'alignement sur |
---|
380 | ** les trois étoiles et ne prend en compte de la torsion de la monture etc... |
---|
381 | ** |
---|
382 | ** Les variables a1, a2, a3 contiennent les coordonnées horaires calculées (AD & Dec) des trois |
---|
383 | ** étoiles visées... |
---|
384 | ** Les variables m1, m2, m3 contiennent les coordonnées horaires effectivement mesurées |
---|
385 | ** de ces trois mêmes objets |
---|
386 | ** |
---|
387 | ***************************************************************************************/ |
---|
388 | |
---|
389 | int Alignement::Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3) |
---|
390 | { |
---|
391 | double x, y, z; |
---|
392 | |
---|
393 | Coord aa1, aa2, aa3; |
---|
394 | Coord mm1, mm2, mm3; |
---|
395 | |
---|
396 | stringstream os; |
---|
397 | |
---|
398 | // Pour chaque variable coordonnées, on calcule d'abord l'azimut et la hauteur de l'objet correspondant |
---|
399 | |
---|
400 | Azimut(a1.x, a1.y, &aa1.x, &aa1.y); |
---|
401 | |
---|
402 | // puis on transforme les coordonnées sphériques (azi, haut) en coordonnées cartésiennes x, y, z |
---|
403 | x=cos(aa1.x) * cos(aa1.y); |
---|
404 | y=sin(aa1.x) * cos(aa1.y); |
---|
405 | z=sin(aa1.y); |
---|
406 | aa1.x=x; |
---|
407 | aa1.y=y; |
---|
408 | aa1.z=z; |
---|
409 | |
---|
410 | Azimut(a2.x, a2.y, &aa2.x, &aa2.y); |
---|
411 | os << "a2.y " << a2.y << "\n"; |
---|
412 | x=cos(aa2.x) * cos(aa2.y); |
---|
413 | y=sin(aa2.x) * cos(aa2.y); |
---|
414 | z=sin(aa2.y); |
---|
415 | aa2.x=x; |
---|
416 | aa2.y=y; |
---|
417 | aa2.z=z; |
---|
418 | |
---|
419 | Azimut(a3.x, a3.y, &aa3.x, &aa3.y); |
---|
420 | os << "a3.y " << a3.y << "\n"; |
---|
421 | x=cos(aa3.x) * cos(aa3.y); |
---|
422 | y=sin(aa3.x) * cos(aa3.y); |
---|
423 | z=sin(aa3.y); |
---|
424 | aa3.x=x; |
---|
425 | aa3.y=y; |
---|
426 | aa3.z=z; |
---|
427 | |
---|
428 | Azimut(m1.x, m1.y, &mm1.x, &mm1.y); |
---|
429 | os << "m1.y " << m1.y << "\n"; |
---|
430 | x=cos(mm1.x) * cos(mm1.y); |
---|
431 | y=sin(mm1.x) * cos(mm1.y); |
---|
432 | z=sin(mm1.y); |
---|
433 | mm1.x=x; |
---|
434 | mm1.y=y; |
---|
435 | mm1.z=z; |
---|
436 | |
---|
437 | Azimut(m2.x, m2.y, &mm2.x, &mm2.y); |
---|
438 | os << "m2.y " << m2.y << "\n"; |
---|
439 | x=cos(mm2.x) * cos(mm2.y); |
---|
440 | y=sin(mm2.x) * cos(mm2.y); |
---|
441 | z=sin(mm2.y); |
---|
442 | mm2.x=x; |
---|
443 | mm2.y=y; |
---|
444 | mm2.z=z; |
---|
445 | |
---|
446 | Azimut(m3.x, m3.y, &mm3.x, &mm3.y); |
---|
447 | os << "m3.y " << m3.y << "\n"; |
---|
448 | x=cos(mm3.x) * cos(mm3.y); |
---|
449 | y=sin(mm3.x) * cos(mm3.y); |
---|
450 | z=sin(mm3.y); |
---|
451 | mm3.x=x; |
---|
452 | mm3.y=y; |
---|
453 | mm3.z=z; |
---|
454 | |
---|
455 | // On se retouvre à devoir résoudre les equations: |
---|
456 | |
---|
457 | // mm1 = aa1 * MATRICE_Correction |
---|
458 | // mm2 = aa2 * MATRICE_Correction |
---|
459 | // mm3 = aa3 * MATRICE_Correction |
---|
460 | |
---|
461 | // et donc à trouver les éléments de la matrice MATRICE_Correction en fonction des paramÚtres x, y, z des vecteurs |
---|
462 | // aa1, aa2, aa3, mm1, mm2, mm3 |
---|
463 | |
---|
464 | // Les éléments de la matrice se trouvent aisément |
---|
465 | |
---|
466 | double div= aa1.z*aa2.y*aa3.x - aa1.y*aa2.z*aa3.x - aa1.z*aa2.x*aa3.y + |
---|
467 | aa1.x*aa2.z*aa3.y + aa1.y*aa2.x*aa3.z - aa1.x*aa2.y*aa3.z; |
---|
468 | |
---|
469 | if ( div !=0.0 ) |
---|
470 | { |
---|
471 | |
---|
472 | double mm11 = -(((-aa2.z)*aa3.y*mm1.x + aa2.y*aa3.z*mm1.x + aa1.z*aa3.y*mm2.x - aa1.y*aa3.z*mm2.x - |
---|
473 | aa1.z*aa2.y*mm3.x + aa1.y*aa2.z*mm3.x)/div); |
---|
474 | |
---|
475 | double mm12 = -((aa2.z*aa3.x*mm1.x - aa2.x*aa3.z*mm1.x - aa1.z*aa3.x*mm2.x + aa1.x*aa3.z*mm2.x + aa1.z*aa2.x*mm3.x - aa1.x*aa2.z*mm3.x)/div); |
---|
476 | |
---|
477 | double mm13 = -(((-aa2.y)*aa3.x*mm1.x + aa2.x*aa3.y*mm1.x + aa1.y*aa3.x*mm2.x - aa1.x*aa3.y*mm2.x - aa1.y*aa2.x*mm3.x + aa1.x*aa2.y*mm3.x)/div); |
---|
478 | |
---|
479 | double mm21 = -(((-aa2.z)*aa3.y*mm1.y + aa2.y*aa3.z*mm1.y + aa1.z*aa3.y*mm2.y - aa1.y*aa3.z*mm2.y - |
---|
480 | aa1.z*aa2.y*mm3.y + aa1.y*aa2.z*mm3.y)/div); |
---|
481 | |
---|
482 | double mm22 = -((aa2.z*aa3.x*mm1.y - aa2.x*aa3.z*mm1.y - aa1.z*aa3.x*mm2.y + aa1.x*aa3.z*mm2.y + aa1.z*aa2.x*mm3.y - |
---|
483 | aa1.x*aa2.z*mm3.y)/div); |
---|
484 | |
---|
485 | double mm23 = -(((-aa2.y)*aa3.x*mm1.y + aa2.x*aa3.y*mm1.y + aa1.y*aa3.x*mm2.y - aa1.x*aa3.y*mm2.y - |
---|
486 | aa1.y*aa2.x*mm3.y + aa1.x*aa2.y*mm3.y)/div); |
---|
487 | |
---|
488 | double mm31 = -(((-aa2.z)*aa3.y*mm1.z + aa2.y*aa3.z*mm1.z + aa1.z*aa3.y*mm2.z - aa1.y*aa3.z*mm2.z - |
---|
489 | aa1.z*aa2.y*mm3.z + aa1.y*aa2.z*mm3.z)/div); |
---|
490 | |
---|
491 | double mm32 = -((aa2.z*aa3.x*mm1.z - aa2.x*aa3.z*mm1.z - aa1.z*aa3.x*mm2.z + aa1.x*aa3.z*mm2.z + aa1.z*aa2.x*mm3.z - |
---|
492 | aa1.x*aa2.z*mm3.z)/div); |
---|
493 | |
---|
494 | double mm33 = -(((-aa2.y)*aa3.x*mm1.z + aa2.x*aa3.y*mm1.z + aa1.y*aa3.x*mm2.z - aa1.x*aa3.y*mm2.z - |
---|
495 | aa1.y*aa2.x*mm3.z + aa1.x*aa2.y*mm3.z)/div); |
---|
496 | |
---|
497 | |
---|
498 | |
---|
499 | MATRICE[1][1] = mm11; |
---|
500 | MATRICE[2][1] = mm12; |
---|
501 | MATRICE[3][1] = mm13; |
---|
502 | |
---|
503 | MATRICE[1][2] = mm21; |
---|
504 | MATRICE[2][2] = mm22; |
---|
505 | MATRICE[3][2] = mm23; |
---|
506 | |
---|
507 | MATRICE[1][3] = mm31; |
---|
508 | MATRICE[2][3] = mm32; |
---|
509 | MATRICE[3][3] = mm33; |
---|
510 | |
---|
511 | //Pour vérifs |
---|
512 | //RotationAutourDunAxe(0.3,Pi/2.0-0.1, 0.2); |
---|
513 | |
---|
514 | return 1; |
---|
515 | } |
---|
516 | else |
---|
517 | { |
---|
518 | return 0; |
---|
519 | } |
---|
520 | } |
---|
521 | |
---|
522 | |
---|
523 | void Alignement::AppliquerMatriceCorrectionSimple(Coord * result, Coord vect) |
---|
524 | { |
---|
525 | // Applique la correction sur le vecteur orientation vect avec |
---|
526 | |
---|
527 | result->x = vect.x * MATRICE[1][1] + vect.y * MATRICE[2][1] + vect.z * MATRICE[3][1]; |
---|
528 | result->y = vect.x * MATRICE[1][2] + vect.y * MATRICE[2][2] + vect.z * MATRICE[3][2]; |
---|
529 | result->z = vect.x * MATRICE[1][3] + vect.y * MATRICE[2][3] + vect.z * MATRICE[3][3]; |
---|
530 | } |
---|
531 | |
---|
532 | |
---|
533 | |
---|
534 | |
---|
535 | /************************************************************************************** |
---|
536 | ** Calcule la surface d'un triangle de coordonnées (px1,py1) (px2, py2) (px3, py3) |
---|
537 | ** |
---|
538 | ***************************************************************************************/ |
---|
539 | |
---|
540 | double Alignement::Surface_Triangle(double px1, double py1, double px2, double py2, double px3, double py3) |
---|
541 | { |
---|
542 | double ta; |
---|
543 | |
---|
544 | ta = (((px2 * py1) - (px1 * py2)) ) + (((px3 * py2) - (px2 * py3)) ) + (((px1 * py3) - (px3 * py1)) ); |
---|
545 | |
---|
546 | return fabs(ta) / 2.0; |
---|
547 | } |
---|
548 | |
---|
549 | |
---|
550 | /************************************************************************************** |
---|
551 | ** Est-ce que le point de coordonnées (px, py) se trouve dans la surface du triangle |
---|
552 | ** de coordonnées (px1,py1) (px2, py2) (px3, py3) ? |
---|
553 | ** |
---|
554 | ***************************************************************************************/ |
---|
555 | |
---|
556 | bool Alignement::PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3) |
---|
557 | { |
---|
558 | double ta; |
---|
559 | double t1; |
---|
560 | double t2; |
---|
561 | double t3; |
---|
562 | |
---|
563 | ta = Surface_Triangle(px1, py1, px2, py2, px3, py3); |
---|
564 | t1 = Surface_Triangle(px, py, px2, py2, px3, py3); |
---|
565 | t2 = Surface_Triangle(px1, py1, px, py, px3, py3); |
---|
566 | t3 = Surface_Triangle(px1, py1, px2, py2, px, py); |
---|
567 | |
---|
568 | stringstream os; |
---|
569 | |
---|
570 | os << fabs(ta - t1 - t2 - t3)<< "\n"; |
---|
571 | AfficherLog(os.str().c_str(), true); |
---|
572 | |
---|
573 | if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false; |
---|
574 | if ( DistanceAngulaireEntre2Points(px, py, px2, py2) > 1.2 ) return false; |
---|
575 | if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false; |
---|
576 | |
---|
577 | return ( fabs(ta - t1 - t2 - t3) < 1e-10 ); |
---|
578 | } |
---|
579 | |
---|
580 | |
---|
581 | /************************************************************************************** |
---|
582 | ** Calcule la matrice de correction issue de la procédure d'alignement des antennes |
---|
583 | ** |
---|
584 | ** Routine principale. On construit ici trois vecteurs c1, c2 et c3 qui contiennent |
---|
585 | ** les coordonnées (issues du catalogue) de trois objets visés pendant la procédure |
---|
586 | ** d'alignement. Les vecteurs m1, m2 et m3 contiennent les coordonnées mesurées |
---|
587 | ** de ces mêmes objets dans le viseur de l'instrument. |
---|
588 | ** |
---|
589 | ***************************************************************************************/ |
---|
590 | |
---|
591 | void Alignement::CalculerMatriceCorrection(double ar, double dec) |
---|
592 | { |
---|
593 | Coord c1, c2, c3, c4, m1, m2, m3, m4; |
---|
594 | |
---|
595 | double a1, b1, a2, b2; |
---|
596 | |
---|
597 | int map[MAXALIGNEMENTANTENNE]; |
---|
598 | |
---|
599 | stringstream os; |
---|
600 | |
---|
601 | int best1 = 0; |
---|
602 | int best2 = 0; |
---|
603 | int best3 = 0; |
---|
604 | |
---|
605 | |
---|
606 | // On calcule le temps sidéral local, etc... |
---|
607 | |
---|
608 | CalculTSL(); |
---|
609 | |
---|
610 | switch ( MethodeAlignement ) |
---|
611 | { |
---|
612 | case SIMPLE : |
---|
613 | { |
---|
614 | best1 = 1; |
---|
615 | best2 = 2; |
---|
616 | best3 = 3; |
---|
617 | |
---|
618 | for (int i=0; i<MAXALIGNEMENTANTENNE; i++) map[i] = i; |
---|
619 | } |
---|
620 | break; |
---|
621 | |
---|
622 | |
---|
623 | case AFFINE: |
---|
624 | case TAKI : |
---|
625 | { |
---|
626 | |
---|
627 | double *distances; |
---|
628 | |
---|
629 | distances = new double [nbrcorrections+1]; |
---|
630 | |
---|
631 | os << "Coordonnées visees : ad=" << DHMS(ar*N180divPi,true) << " de=" << DHMS(dec*N180divPi,false) << "\n"; |
---|
632 | |
---|
633 | Azimut(VerifAngle(ar-GetTSL()), dec, &a2, &b2); |
---|
634 | |
---|
635 | for (int i=1; i<=nbrcorrections; i++) |
---|
636 | { |
---|
637 | Azimut(VerifAngle(ad[i]-tsl[i]),de[i], &a1, &b1); |
---|
638 | |
---|
639 | distances[i] = DistanceAngulaireEntre2Points(a1, b1, a2, b2); |
---|
640 | |
---|
641 | map[i]=i; |
---|
642 | } |
---|
643 | |
---|
644 | for (int i=1; i<=nbrcorrections; i++) |
---|
645 | { |
---|
646 | for (int j=i+1; j<=nbrcorrections; j++) |
---|
647 | { |
---|
648 | if (distances[j]<distances[i]) |
---|
649 | { |
---|
650 | double bout=distances[i]; |
---|
651 | distances[i]=distances[j]; |
---|
652 | distances[j]=bout; |
---|
653 | |
---|
654 | int bout2=map[i]; |
---|
655 | map[i]=map[j]; |
---|
656 | map[j]=bout2; |
---|
657 | } |
---|
658 | } |
---|
659 | } |
---|
660 | |
---|
661 | for (int i=1; i<=nbrcorrections; i++) |
---|
662 | { |
---|
663 | os << "Point " << map[i] << " d=" << distances[i] << "\n"; |
---|
664 | } |
---|
665 | |
---|
666 | for (int i=1; i<=nbrcorrections; i++) |
---|
667 | { |
---|
668 | for (int j=i+1; j<=nbrcorrections; j++) |
---|
669 | { |
---|
670 | for (int k=j+1; k<=nbrcorrections; k++) |
---|
671 | { |
---|
672 | double a,b; |
---|
673 | |
---|
674 | os << "Triangle : " << map[i] << " " << map[j] << " " << map[k] << "\n"; |
---|
675 | |
---|
676 | os << "Objet "; |
---|
677 | |
---|
678 | os << ": az=" << DHMS(a2*N180divPi, false) << " ha=" << DHMS(b2*N180divPi, false) << "\n"; |
---|
679 | |
---|
680 | os << "Etoile " << i ; |
---|
681 | |
---|
682 | Azimut(VerifAngle(ad[map[i]]-tsl[map[i]]), de[map[i]], &a, &b); |
---|
683 | |
---|
684 | os << ": az=" << DHMS(a*N180divPi, false) << " ha=" << DHMS(b*N180divPi, false) << "\n"; |
---|
685 | |
---|
686 | os << "Etoile " << j ; |
---|
687 | |
---|
688 | Azimut(VerifAngle(ad[map[j]]-tsl[map[j]]), de[map[j]], &a, &b); |
---|
689 | |
---|
690 | os << ": az=" << DHMS(a*N180divPi, false) << " ha=" << DHMS(b*N180divPi, false) << "\n"; |
---|
691 | |
---|
692 | os << "Etoile " << k ; |
---|
693 | |
---|
694 | Azimut(VerifAngle(ad[map[k]]-tsl[map[k]]), de[map[k]], &a, &b); |
---|
695 | |
---|
696 | os << ": az=" << DHMS(a*N180divPi, false) << " ha=" << DHMS(b*N180divPi, false) << "\n"; |
---|
697 | |
---|
698 | AfficherLog(&os, true); |
---|
699 | |
---|
700 | if (PointSitueDansSurfaceTriangle(VerifAngle(ar-GetTSL()), dec, |
---|
701 | VerifAngle(ad[map[i]]-tsl[map[i]]), de[map[i]], |
---|
702 | VerifAngle(ad[map[j]]-tsl[map[j]]), de[map[j]], |
---|
703 | VerifAngle(ad[map[k]]-tsl[map[k]]), de[map[k]])) |
---|
704 | { |
---|
705 | best1=i; |
---|
706 | best2=j; |
---|
707 | best3=k; |
---|
708 | k=1000; |
---|
709 | j=1000; |
---|
710 | i=1000; |
---|
711 | } |
---|
712 | } |
---|
713 | } |
---|
714 | } |
---|
715 | |
---|
716 | delete [] distances; |
---|
717 | } |
---|
718 | break; |
---|
719 | } |
---|
720 | |
---|
721 | |
---|
722 | |
---|
723 | if ( best1 == 0 && best2 == 0 && best3 == 0 ) |
---|
724 | { |
---|
725 | if (MethodeAlignement == AFFINE || MethodeAlignement == TAKI) |
---|
726 | { |
---|
727 | ErreurLog("Erreur ! Pas de triangle disponible pour la correction !\nLe positionnement de l antenne sera approximatif !\n"); |
---|
728 | } |
---|
729 | |
---|
730 | Identity(); |
---|
731 | |
---|
732 | Matrice_ok = false; |
---|
733 | |
---|
734 | return; |
---|
735 | } |
---|
736 | else |
---|
737 | { |
---|
738 | os << "\nUtilisation du triangle : " << map[best1] << " " << map[best2] << " " << map[best3] << "\n" ; |
---|
739 | |
---|
740 | c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL()); |
---|
741 | c1.y = de[map[best1]]; |
---|
742 | c1.z = 1.0; |
---|
743 | |
---|
744 | c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL()); |
---|
745 | c2.y = de[map[best2]]; |
---|
746 | c2.z = 1.0; |
---|
747 | |
---|
748 | c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL()); |
---|
749 | c3.y = de[map[best3]]; |
---|
750 | c3.z = 1.0; |
---|
751 | |
---|
752 | os << "Point 1 : ho=" << DHMS(c1.x * N180divPi, false); |
---|
753 | os << " de=" << DHMS(c1.y *N180divPi, false) <<"\n"; |
---|
754 | os << "Point 2 : ho=" << DHMS(c2.x * N180divPi, false); |
---|
755 | os << " de=" << DHMS(c2.y * N180divPi, false) <<"\n"; |
---|
756 | os << "Point 3 : ho=" << DHMS(c3.x * N180divPi, false); |
---|
757 | os << " de=" << DHMS(c3.y * N180divPi, false) <<"\n\n"; |
---|
758 | |
---|
759 | |
---|
760 | m1.x = VerifAngle(c1.x + (double)delta_ad[map[best1]] * PasDeltaAD); |
---|
761 | m1.y = c1.y + (double)delta_de[map[best1]] * PasDeltaDe; |
---|
762 | m1.z = 1.0; |
---|
763 | |
---|
764 | m2.x = VerifAngle(c2.x + (double)delta_ad[map[best2]] * PasDeltaAD); |
---|
765 | m2.y = c2.y + (double)delta_de[map[best2]] * PasDeltaDe; |
---|
766 | m2.z = 1.0; |
---|
767 | |
---|
768 | m3.x = VerifAngle(c3.x + (double)delta_ad[map[best3]] * PasDeltaAD); |
---|
769 | m3.y = c3.y + (double)delta_de[map[best3]] * PasDeltaDe; |
---|
770 | m3.z = 1.0; |
---|
771 | } |
---|
772 | |
---|
773 | // Calcul de la matrice de correction en fonction de la méthode d'alignement |
---|
774 | |
---|
775 | switch (MethodeAlignement) |
---|
776 | { |
---|
777 | case SIMPLE: |
---|
778 | os << "Methode d alignement SIMPLE\n"; |
---|
779 | Matrice_ok = Calculer_Matrice_Simple(c1, c2, c3 ,m1, m2, m3); |
---|
780 | break; |
---|
781 | case AFFINE: |
---|
782 | os << "Methode d alignement AFFINE\n"; |
---|
783 | Matrice_ok = Calculer_Matrice_Affine( VerifAngle( ar - GetTSL() ), dec, c1, c2, c3 ,m1, m2, m3); |
---|
784 | break; |
---|
785 | case TAKI: |
---|
786 | os << "Methode d alignement TAKI\n"; |
---|
787 | Matrice_ok = Calculer_Matrice_Taki ( VerifAngle( ar - GetTSL() ), dec, c1, c2, c3 ,m1, m2, m3); |
---|
788 | break; |
---|
789 | } |
---|
790 | |
---|
791 | |
---|
792 | // Affiche de la matrice pour vérif |
---|
793 | |
---|
794 | os << "\nCalcul de la matrice de correction:\n"; |
---|
795 | os << MATRICE[1][1] << " \t" << MATRICE[2][1] << " \t" << MATRICE[3][1] << "\n"; |
---|
796 | os << MATRICE[1][2] << " \t" << MATRICE[2][2] << " \t" << MATRICE[3][2] << "\n"; |
---|
797 | os << MATRICE[1][3] << " \t" << MATRICE[2][3] << " \t" << MATRICE[3][3] << "\n"; |
---|
798 | |
---|
799 | |
---|
800 | |
---|
801 | |
---|
802 | |
---|
803 | |
---|
804 | //Vérifications supp |
---|
805 | /* |
---|
806 | Coord result, mm1; |
---|
807 | double targetAz, targetAlt; |
---|
808 | |
---|
809 | os << "\n\n\n" << GetLatitude()*N180divPi << " " << GetLongitude()*N180divPi << "\n"; |
---|
810 | os << GetPression() << " " << GetTemperature() << "\n"; |
---|
811 | os << GetHeure() << ":" << GetMin() << ":" << GetSec() << "\n"; |
---|
812 | os << DHMS(GetTSL()*N180divPi, true) << "\n\n"; |
---|
813 | |
---|
814 | Azimut(c3.x, c3.y, &mm1.x, &mm1.y); |
---|
815 | |
---|
816 | os << mm1.x*N180divPi << " " << mm1.y*N180divPi << "\n"; |
---|
817 | |
---|
818 | |
---|
819 | Azimut(m3.x, m3.y, &mm1.x, &mm1.y); |
---|
820 | |
---|
821 | os << mm1.x*N180divPi << " " << mm1.y*N180divPi << "\n"; |
---|
822 | |
---|
823 | |
---|
824 | Azimut(c3.x, c3.y, &mm1.x, &mm1.y); |
---|
825 | |
---|
826 | double x=cos(mm1.x) * cos(mm1.y); |
---|
827 | double y=sin(mm1.x) * cos(mm1.y); |
---|
828 | double z=sin(mm1.y); |
---|
829 | mm1.x=x; |
---|
830 | mm1.y=y; |
---|
831 | mm1.z=z; |
---|
832 | |
---|
833 | AppliquerMatriceCorrectionSimple(&result, mm1); |
---|
834 | |
---|
835 | if (result.x != 0.0) |
---|
836 | { |
---|
837 | targetAz = atan( result.y / result.x ); |
---|
838 | |
---|
839 | if (result.x < 0) targetAz+=Pi; |
---|
840 | } |
---|
841 | else targetAz = Pidiv2; |
---|
842 | |
---|
843 | targetAz = VerifAngle(targetAz); |
---|
844 | |
---|
845 | targetAlt = asin(result.z); |
---|
846 | |
---|
847 | os << targetAz*N180divPi << " " << targetAlt*N180divPi << "\n"; |
---|
848 | */ |
---|
849 | |
---|
850 | |
---|
851 | |
---|
852 | //Afficher les messages de cette fonction |
---|
853 | |
---|
854 | AfficherLog(os.str(), true); |
---|
855 | } |
---|
856 | |
---|
857 | |
---|
858 | |
---|
859 | /************************************************************************************** |
---|
860 | ** Le fichier file existe-t-il et n'est-il pas vide ? |
---|
861 | **************************************************************************************/ |
---|
862 | |
---|
863 | bool Alignement::is_readable( const std::string & file ) |
---|
864 | { |
---|
865 | std::ifstream fichier( file.c_str() ); |
---|
866 | if (fichier.fail()) return false; |
---|
867 | |
---|
868 | // sauvegarder la position courante |
---|
869 | long pos = fichier.tellg(); |
---|
870 | // se placer en fin de fichier |
---|
871 | fichier.seekg( 0 , std::ios_base::end ); |
---|
872 | // récupérer la nouvelle position = la taille du fichier |
---|
873 | long size = fichier.tellg(); |
---|
874 | return (size > 0); |
---|
875 | } |
---|
876 | |
---|
877 | |
---|
878 | /************************************************************************************** |
---|
879 | ** Chargement des paramÚtres d'alignement des antennes |
---|
880 | **************************************************************************************/ |
---|
881 | |
---|
882 | bool Alignement::ChargementParametresAlignement(string IP, string fileName, double a, double b) |
---|
883 | { |
---|
884 | static double mema = a; |
---|
885 | |
---|
886 | static double memb = b; |
---|
887 | |
---|
888 | string value; |
---|
889 | |
---|
890 | stringstream os, os2; |
---|
891 | |
---|
892 | char *delta_az_polar_data = NULL; |
---|
893 | |
---|
894 | char *ad_data = NULL; |
---|
895 | |
---|
896 | char *de_data = NULL; |
---|
897 | |
---|
898 | char *delta_ad_data = NULL; |
---|
899 | |
---|
900 | char *delta_de_data = NULL; |
---|
901 | |
---|
902 | char *align_data = NULL; |
---|
903 | |
---|
904 | char *alignment_method_data = NULL; |
---|
905 | |
---|
906 | char *tsl_data = NULL; |
---|
907 | |
---|
908 | |
---|
909 | if (!is_readable(fileName)) return false; |
---|
910 | |
---|
911 | // Chargement des corrections des antennes |
---|
912 | |
---|
913 | bool modificationAlignement = false; |
---|
914 | |
---|
915 | // On sélectionne la bonne antenne (à partir de son adresse ip). |
---|
916 | |
---|
917 | if (IP.rfind(".") != string::npos) IP = IP.substr(IP.rfind(".")+1); |
---|
918 | |
---|
919 | |
---|
920 | os << "Alignement antenne ip x.x.x." << IP; |
---|
921 | |
---|
922 | |
---|
923 | //nbrcorrections = 0; TODO semble poser un problÚme |
---|
924 | |
---|
925 | |
---|
926 | for (int j=1; j < MAXALIGNEMENTANTENNE; j++) |
---|
927 | { |
---|
928 | os2 << "ad " << j; |
---|
929 | |
---|
930 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &ad_data, (char*)fileName.c_str()); |
---|
931 | |
---|
932 | os2.str(""); |
---|
933 | |
---|
934 | os2 << "de " << j; |
---|
935 | |
---|
936 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &de_data, (char*)fileName.c_str()); |
---|
937 | |
---|
938 | os2.str(""); |
---|
939 | |
---|
940 | os2 << "delta_ad " << j; |
---|
941 | |
---|
942 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_ad_data, (char*)fileName.c_str()); |
---|
943 | |
---|
944 | os2.str(""); |
---|
945 | |
---|
946 | os2 << "delta_de " << j; |
---|
947 | |
---|
948 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_de_data, (char*)fileName.c_str()); |
---|
949 | |
---|
950 | os2.str(""); |
---|
951 | |
---|
952 | os2 << "tsl " << j; |
---|
953 | |
---|
954 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &tsl_data, (char*)fileName.c_str()); |
---|
955 | |
---|
956 | os2.str(""); |
---|
957 | |
---|
958 | |
---|
959 | if ( ad_data && de_data && delta_ad_data && delta_de_data |
---|
960 | && tsl_data && atof(tsl_data)!=0.0 && atof(ad_data)!=0.0 && atof(de_data)!=0.0) |
---|
961 | { |
---|
962 | // Si les corrections de l'antenne i ont été modifiées depuis le démarrage du programme |
---|
963 | // -> on les applique... |
---|
964 | |
---|
965 | nbrcorrections = j; |
---|
966 | |
---|
967 | if (delta_ad[j] != atol(delta_ad_data) || delta_de[j] != atol(delta_de_data)) |
---|
968 | { |
---|
969 | ad[j] = atof(ad_data); |
---|
970 | |
---|
971 | de[j] = atof(de_data); |
---|
972 | |
---|
973 | delta_ad[j] = atol(delta_ad_data); |
---|
974 | |
---|
975 | delta_de[j] = atol(delta_de_data); |
---|
976 | |
---|
977 | tsl[j] = atof(tsl_data); |
---|
978 | |
---|
979 | os2 << "Correction antenne ip=" << IP << " ad=" << ad[j] << " de=" << de[j] << " deltaAD=" << delta_ad[j] << " deltaDe=" << delta_de[j] << " tsl=" << tsl[j] << "\n"; |
---|
980 | |
---|
981 | AfficherLog(&os2, true); |
---|
982 | |
---|
983 | modificationAlignement = true; |
---|
984 | } |
---|
985 | } |
---|
986 | |
---|
987 | SAFEDELETE_TAB(ad_data); |
---|
988 | |
---|
989 | SAFEDELETE_TAB(de_data); |
---|
990 | |
---|
991 | SAFEDELETE_TAB(delta_ad_data); |
---|
992 | |
---|
993 | SAFEDELETE_TAB(delta_de_data); |
---|
994 | |
---|
995 | SAFEDELETE_TAB(tsl_data); |
---|
996 | } |
---|
997 | |
---|
998 | os2 << "delta_az_polar"; |
---|
999 | |
---|
1000 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_az_polar_data, (char*)fileName.c_str()); |
---|
1001 | |
---|
1002 | os2.str(""); |
---|
1003 | |
---|
1004 | if (delta_az_polar_data) |
---|
1005 | { |
---|
1006 | if ( delta_az_polar != atol(delta_az_polar_data) ) |
---|
1007 | { |
---|
1008 | delta_az_polar = atol(delta_az_polar_data); |
---|
1009 | |
---|
1010 | modificationAlignement = true; |
---|
1011 | } |
---|
1012 | } |
---|
1013 | |
---|
1014 | os2 << "alignment_method"; |
---|
1015 | |
---|
1016 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &alignment_method_data, (char*)fileName.c_str()); |
---|
1017 | |
---|
1018 | os2.str(""); |
---|
1019 | |
---|
1020 | if (alignment_method_data) |
---|
1021 | { |
---|
1022 | if ( MethodeAlignement != atoi(alignment_method_data) ) |
---|
1023 | { |
---|
1024 | MethodeAlignement = atoi(alignment_method_data); |
---|
1025 | |
---|
1026 | modificationAlignement = true; |
---|
1027 | } |
---|
1028 | } |
---|
1029 | |
---|
1030 | os2 << "align"; |
---|
1031 | |
---|
1032 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &align_data, (char*)fileName.c_str()); |
---|
1033 | |
---|
1034 | os2.str(""); |
---|
1035 | |
---|
1036 | |
---|
1037 | if (align_data) |
---|
1038 | { |
---|
1039 | // Si la procédure d'alignement se termine, il faut calculer la matrice de correction |
---|
1040 | |
---|
1041 | if (AlignementEnCours != atoi(align_data)) |
---|
1042 | { |
---|
1043 | AlignementEnCours = atoi(align_data); |
---|
1044 | |
---|
1045 | modificationAlignement = true; |
---|
1046 | } |
---|
1047 | } |
---|
1048 | |
---|
1049 | if (mema!=a || memb!=b) |
---|
1050 | { |
---|
1051 | mema = a; |
---|
1052 | |
---|
1053 | memb = b; |
---|
1054 | |
---|
1055 | modificationAlignement = true; |
---|
1056 | } |
---|
1057 | |
---|
1058 | // si nbrcorrections=0 (suite à l'utilisation de la commande reset dans BAOcontrol par ex) il faut |
---|
1059 | // réinitialiser la matrice |
---|
1060 | |
---|
1061 | if (nbrcorrections == 0 ) modificationAlignement = true; |
---|
1062 | |
---|
1063 | |
---|
1064 | // Si un des paramÚtres d'une antenne change pendant la procédure d'alignement ou que l'on a |
---|
1065 | // plus de deux points d'alignement sur une antenne, alors on calcule la matrice de correction |
---|
1066 | |
---|
1067 | if (modificationAlignement) |
---|
1068 | { |
---|
1069 | if (nbrcorrections >=3 && AlignementEnCours == 0) |
---|
1070 | { |
---|
1071 | // IDLog("Calcul matrice\n", true); |
---|
1072 | CalculerMatriceCorrection(a, b); |
---|
1073 | } |
---|
1074 | else |
---|
1075 | { |
---|
1076 | Identity(); |
---|
1077 | |
---|
1078 | Matrice_ok = false; |
---|
1079 | } |
---|
1080 | } |
---|
1081 | |
---|
1082 | SAFEDELETE_TAB(delta_az_polar_data); |
---|
1083 | |
---|
1084 | SAFEDELETE_TAB(alignment_method_data); |
---|
1085 | |
---|
1086 | SAFEDELETE_TAB(align_data); |
---|
1087 | |
---|
1088 | return true; |
---|
1089 | } |
---|
1090 | |
---|
1091 | |
---|
1092 | |
---|
1093 | /************************************************************************************** |
---|
1094 | ** Sauvegarde des paramÚtres d'alignement des antennes |
---|
1095 | ***************************************************************************************/ |
---|
1096 | |
---|
1097 | bool Alignement::EnregistrementParametresAlignement(string IP, string fileName) |
---|
1098 | { |
---|
1099 | string section; |
---|
1100 | string key; |
---|
1101 | string value; |
---|
1102 | |
---|
1103 | stringstream os; |
---|
1104 | |
---|
1105 | |
---|
1106 | //AfficherLog("Enregistrement de l'alignement des antennes dans le fichier " + fileName + "\n", true); |
---|
1107 | |
---|
1108 | //Enregistrement des corrections des l'antennes |
---|
1109 | |
---|
1110 | os << "Alignement antenne ip x.x.x." << IP; |
---|
1111 | section = os.str(); |
---|
1112 | os.str(""); |
---|
1113 | |
---|
1114 | os << "delta_az_polar"; |
---|
1115 | key = os.str(); |
---|
1116 | os.str(""); |
---|
1117 | os << delta_az_polar; |
---|
1118 | value = os.str(); |
---|
1119 | os.str(""); |
---|
1120 | |
---|
1121 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1122 | |
---|
1123 | os << "align"; |
---|
1124 | key = os.str(); |
---|
1125 | os.str(""); |
---|
1126 | (AlignementEnCours == true) ? os << "1" : os << "0"; |
---|
1127 | value = os.str(); |
---|
1128 | os.str(""); |
---|
1129 | |
---|
1130 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1131 | |
---|
1132 | os << "alignment_method"; |
---|
1133 | key = os.str(); |
---|
1134 | os.str(""); |
---|
1135 | os << MethodeAlignement; |
---|
1136 | value = os.str(); |
---|
1137 | os.str(""); |
---|
1138 | |
---|
1139 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1140 | |
---|
1141 | |
---|
1142 | for (int j = 1; j <= MAXALIGNEMENTANTENNE; j++) |
---|
1143 | { |
---|
1144 | os << "ad " << j; |
---|
1145 | key = os.str(); |
---|
1146 | os.str(""); |
---|
1147 | os << 0.0; |
---|
1148 | value = os.str(); |
---|
1149 | os.str(""); |
---|
1150 | |
---|
1151 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1152 | |
---|
1153 | os << "de " << j; |
---|
1154 | key = os.str(); |
---|
1155 | os.str(""); |
---|
1156 | os << 0.0; |
---|
1157 | value = os.str(); |
---|
1158 | os.str(""); |
---|
1159 | |
---|
1160 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1161 | |
---|
1162 | os << "delta_ad " << j; |
---|
1163 | key = os.str(); |
---|
1164 | os.str(""); |
---|
1165 | os << 0; |
---|
1166 | value = os.str(); |
---|
1167 | os.str(""); |
---|
1168 | |
---|
1169 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1170 | |
---|
1171 | os << "delta_de " << j; |
---|
1172 | key = os.str(); |
---|
1173 | os.str(""); |
---|
1174 | os << 0; |
---|
1175 | value = os.str(); |
---|
1176 | os.str(""); |
---|
1177 | |
---|
1178 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1179 | |
---|
1180 | os << "tsl " << j; |
---|
1181 | key = os.str(); |
---|
1182 | os.str(""); |
---|
1183 | os << 0.0; |
---|
1184 | value = os.str(); |
---|
1185 | os.str(""); |
---|
1186 | |
---|
1187 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1188 | } |
---|
1189 | |
---|
1190 | |
---|
1191 | for (int j = 1; j <= nbrcorrections; j++) |
---|
1192 | { |
---|
1193 | os << "ad " << j; |
---|
1194 | key = os.str(); |
---|
1195 | os.str(""); |
---|
1196 | os << ad[j]; |
---|
1197 | value = os.str(); |
---|
1198 | os.str(""); |
---|
1199 | |
---|
1200 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1201 | |
---|
1202 | os << "de " << j; |
---|
1203 | key = os.str(); |
---|
1204 | os.str(""); |
---|
1205 | os << de[j]; |
---|
1206 | value = os.str(); |
---|
1207 | os.str(""); |
---|
1208 | |
---|
1209 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1210 | |
---|
1211 | os << "delta_ad " << j; |
---|
1212 | key = os.str(); |
---|
1213 | os.str(""); |
---|
1214 | os << delta_ad[j]; |
---|
1215 | value = os.str(); |
---|
1216 | os.str(""); |
---|
1217 | |
---|
1218 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1219 | |
---|
1220 | os << "delta_de " << j; |
---|
1221 | key = os.str(); |
---|
1222 | os.str(""); |
---|
1223 | os << delta_de[j]; |
---|
1224 | value = os.str(); |
---|
1225 | os.str(""); |
---|
1226 | |
---|
1227 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1228 | |
---|
1229 | os << "tsl " << j; |
---|
1230 | key = os.str(); |
---|
1231 | os.str(""); |
---|
1232 | os << tsl[j]; |
---|
1233 | value = os.str(); |
---|
1234 | os.str(""); |
---|
1235 | |
---|
1236 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1237 | } |
---|
1238 | |
---|
1239 | |
---|
1240 | return true; |
---|
1241 | } |
---|
1242 | |
---|
1243 | |
---|
1244 | bool Alignement::EnregistrementParametresAlignement(int IP, string fileName) |
---|
1245 | { |
---|
1246 | stringstream os; |
---|
1247 | |
---|
1248 | os << IP; |
---|
1249 | |
---|
1250 | return EnregistrementParametresAlignement(os.str(), fileName); |
---|
1251 | } |
---|