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 | #include <QtCore/qvariant.h> |
---|
12 | |
---|
13 | |
---|
14 | /************************************************************************************** |
---|
15 | ** Constructeur de la classe Alignement |
---|
16 | ** |
---|
17 | ***************************************************************************************/ |
---|
18 | |
---|
19 | Alignement::Alignement() |
---|
20 | { |
---|
21 | //Initialisation des paramÚtres des antennes |
---|
22 | |
---|
23 | InitAlignement(); |
---|
24 | |
---|
25 | |
---|
26 | // initialisation des paramÚtres géométriques de l'antenne |
---|
27 | |
---|
28 | InitParametresInstrument(); |
---|
29 | } |
---|
30 | |
---|
31 | |
---|
32 | /************************************************************************************** |
---|
33 | ** Destructeur de la classe Alignement |
---|
34 | ** |
---|
35 | ***************************************************************************************/ |
---|
36 | |
---|
37 | Alignement::~Alignement() |
---|
38 | { |
---|
39 | } |
---|
40 | |
---|
41 | |
---|
42 | /************************************************************************************** |
---|
43 | ** Initialisations des vecteurs et des paramÚtres d'alignement |
---|
44 | ** |
---|
45 | ***************************************************************************************/ |
---|
46 | |
---|
47 | void Alignement::InitAlignement() |
---|
48 | { |
---|
49 | // On initialise les points de correction |
---|
50 | |
---|
51 | for (int i=0; i< MAXALIGNEMENTANTENNE; i++) |
---|
52 | { |
---|
53 | <<<<<<< .mine |
---|
54 | ad[i] = 0.0; |
---|
55 | de[i] = 0.0; |
---|
56 | delta_ad[i] = 0.0; |
---|
57 | delta_de[i] = 0.0; |
---|
58 | tsl[i] = 0.0; |
---|
59 | SelectionnePourCalculMatrice[i] = false; |
---|
60 | ======= |
---|
61 | ad[i] = 0.0; |
---|
62 | de[i] = 0.0; |
---|
63 | delta_ad[i] = 0.0; |
---|
64 | delta_de[i] = 0.0; |
---|
65 | tsl[i] = 0.0; |
---|
66 | SelectionnePourCalculMatrice[i] = false; |
---|
67 | >>>>>>> .r680 |
---|
68 | } |
---|
69 | |
---|
70 | // initialisation de la matrice de rotation (à la matrice identité) |
---|
71 | |
---|
72 | Identity(); |
---|
73 | |
---|
74 | |
---|
75 | // initialisation de la direction en azimut de l'étoile polaire |
---|
76 | |
---|
77 | delta_az_polar = 0; |
---|
78 | |
---|
79 | // Initialisation des deltas sur les axes az et ha |
---|
80 | // pour gérer la raquette hors procédure d'alignement |
---|
81 | |
---|
82 | deltaAZ = 0; |
---|
83 | deltaHA = 0; |
---|
84 | |
---|
85 | // Nbre de points (de mesures) actuellement disponibles pour |
---|
86 | // bâtir les matrices de correction |
---|
87 | |
---|
88 | nbrcorrections = 0; |
---|
89 | |
---|
90 | // Est-ce que l'antenne est en cours d'alignement ? |
---|
91 | |
---|
92 | AlignementEnCours = 0; |
---|
93 | |
---|
94 | // La matrice de correction a-t-elle été calculée ? |
---|
95 | |
---|
96 | Matrice_ok = false; |
---|
97 | |
---|
98 | // Méthode d'alignement par défaut |
---|
99 | |
---|
100 | MethodeAlignement = SIMPLE; |
---|
101 | } |
---|
102 | |
---|
103 | |
---|
104 | |
---|
105 | /************************************************************************************** |
---|
106 | ** Initialisation des paramÚtres de la classe astro |
---|
107 | ** |
---|
108 | ***************************************************************************************/ |
---|
109 | |
---|
110 | void Alignement::TransmettreParametresClasseAstro(double Annee, double Mois, double Jour, double Heu, double Min, double Sec, double Longitude, double Latitude, double Pression, double Temp) |
---|
111 | { |
---|
112 | DefinirLongitudeLatitude(Longitude, Latitude); |
---|
113 | DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec); |
---|
114 | DefinirPressionTemp(Pression, Temp); |
---|
115 | } |
---|
116 | |
---|
117 | |
---|
118 | /************************************************************************************** |
---|
119 | ** 1 0 0 |
---|
120 | ** 0 1 0 |
---|
121 | ** 0 0 1 |
---|
122 | ***************************************************************************************/ |
---|
123 | |
---|
124 | void Alignement::Identity() |
---|
125 | { |
---|
126 | MATRICE[1][1] = 1.0; |
---|
127 | MATRICE[2][1] = 0.0; |
---|
128 | MATRICE[3][1] = 0.0; |
---|
129 | |
---|
130 | MATRICE[1][2] = 0.0; |
---|
131 | MATRICE[2][2] = 1.0; |
---|
132 | MATRICE[3][2] = 0.0; |
---|
133 | |
---|
134 | MATRICE[1][3] = 0.0; |
---|
135 | MATRICE[2][3] = 0.0; |
---|
136 | MATRICE[3][3] = 1.0; |
---|
137 | } |
---|
138 | |
---|
139 | |
---|
140 | |
---|
141 | /************************************************************************************** |
---|
142 | ** Calcule la matrice de rotation d'un angle alpha autour d'un axe défini |
---|
143 | ** par les paramÚtres t et r dans un systÚme de coordonnées spĥériques |
---|
144 | ** Le signe - devant le cos permet seulement de rendre le repÚre compatible avec WinStars |
---|
145 | ** que j'utilise pour faire des vérifications... |
---|
146 | ** Fonction utile pour de débogage de la fct d'alignement |
---|
147 | ** |
---|
148 | ***************************************************************************************/ |
---|
149 | |
---|
150 | void Alignement::RotationAutourDunAxe(double t, double r, double alpha) |
---|
151 | { |
---|
152 | double x = -cos(t) * cos(r); |
---|
153 | double y = sin(t) * cos(r); |
---|
154 | double z = sin(r); |
---|
155 | |
---|
156 | double c = cos(alpha); |
---|
157 | double s = sin(alpha); |
---|
158 | |
---|
159 | |
---|
160 | MATRICE[1][1] = x * x + (1.0 - x * x) * c; |
---|
161 | MATRICE[1][2] = x * y * (1.0 - c) - z * s; |
---|
162 | MATRICE[1][3] = x * z * (1.0 - c) + y * s; |
---|
163 | |
---|
164 | MATRICE[2][1] = x * y * (1.0 - c) + z * s; |
---|
165 | MATRICE[2][2] = y * y + (1.0 - y * y) * c; |
---|
166 | MATRICE[2][3] = y * z * (1.0 - c) - x * s; |
---|
167 | |
---|
168 | MATRICE[3][1] = x * z * (1.0 - c) - y * s; |
---|
169 | MATRICE[3][2] = y * z * (1.0 - c) + x * s; |
---|
170 | MATRICE[3][3] = z * z + (1.0 - z * z) * c; |
---|
171 | } |
---|
172 | |
---|
173 | |
---|
174 | /************************************************************************************** |
---|
175 | ** Matrice intermédiaire nécessaire au calcul de la matrice de correction |
---|
176 | ** dans le mode d'alignement TAKI |
---|
177 | ** Consultez la documentation pour comprendre le principe de la correction AFFINE/TAKI |
---|
178 | ** |
---|
179 | ***************************************************************************************/ |
---|
180 | |
---|
181 | void Alignement::Calculer_Matrice_LMN(Coord p1, Coord p2, Coord p3) |
---|
182 | { |
---|
183 | double temp[4][4]; |
---|
184 | double UnitVect[4][4]; |
---|
185 | |
---|
186 | temp[1][1] = p2.x - p1.x; |
---|
187 | temp[2][1] = p3.x - p1.x; |
---|
188 | |
---|
189 | temp[1][2] = p2.y - p1.y; |
---|
190 | temp[2][2] = p3.y - p1.y; |
---|
191 | |
---|
192 | temp[1][3] = p2.z - p1.z; |
---|
193 | temp[2][3] = p3.z - p1.z; |
---|
194 | |
---|
195 | UnitVect[1][1] = (temp[1][2] * temp[2][3]) - (temp[1][3] * temp[2][2]); |
---|
196 | UnitVect[1][2] = (temp[1][3] * temp[2][1]) - (temp[1][1] * temp[2][3]); |
---|
197 | UnitVect[1][3] = (temp[1][1] * temp[2][2]) - (temp[1][2] * temp[2][1]); |
---|
198 | UnitVect[2][1] = pow(UnitVect[1][1], 2.0) + pow(UnitVect[1][2], 2.0) + pow (UnitVect[1][3], 2.0); |
---|
199 | UnitVect[2][2] = sqrt(UnitVect[2][1]); |
---|
200 | UnitVect[2][3] = 0.0; |
---|
201 | if (UnitVect[2][2] != 0.0) UnitVect[2][3] = 1.0 / UnitVect[2][2]; |
---|
202 | |
---|
203 | for (int i=1; i<=2; i++) for (int j=1; j<=3; j++) GETLMN[i][j] = temp[i][j]; |
---|
204 | |
---|
205 | GETLMN[3][1] = UnitVect[2][3] * UnitVect[1][1]; |
---|
206 | GETLMN[3][2] = UnitVect[2][3] * UnitVect[1][2]; |
---|
207 | GETLMN[3][3] = UnitVect[2][3] * UnitVect[1][3]; |
---|
208 | } |
---|
209 | |
---|
210 | |
---|
211 | |
---|
212 | /************************************************************************************** |
---|
213 | ** Calcul de la matrice de correction dans le mode d'alignement TAKI |
---|
214 | ** |
---|
215 | ***************************************************************************************/ |
---|
216 | |
---|
217 | int Alignement::Calculer_Matrice_Taki(double x, double y, Coord aa1, Coord aa2, Coord aa3, Coord mm1, Coord mm2, Coord mm3) |
---|
218 | { |
---|
219 | double Det; |
---|
220 | double EQLMN1[4][4]; |
---|
221 | double EQLMN2[4][4]; |
---|
222 | double EQMI_T[4][4]; |
---|
223 | |
---|
224 | Coord a1, a2, a3, m1, m2, m3; |
---|
225 | |
---|
226 | AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y); |
---|
227 | AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y); |
---|
228 | AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y); |
---|
229 | |
---|
230 | <<<<<<< .mine |
---|
231 | Coord a1, a2, a3, m1, m2, m3; |
---|
232 | ======= |
---|
233 | AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y); |
---|
234 | AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y); |
---|
235 | AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y); |
---|
236 | |
---|
237 | //construit les matrices EQLMN1 & 2 |
---|
238 | >>>>>>> .r680 |
---|
239 | |
---|
240 | <<<<<<< .mine |
---|
241 | AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y); |
---|
242 | AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y); |
---|
243 | AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y); |
---|
244 | ======= |
---|
245 | Calculer_Matrice_LMN(m1, m2, m3); |
---|
246 | >>>>>>> .r680 |
---|
247 | |
---|
248 | <<<<<<< .mine |
---|
249 | AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y); |
---|
250 | AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y); |
---|
251 | AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y); |
---|
252 | ======= |
---|
253 | for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQLMN1[i][j]=GETLMN[i][j]; |
---|
254 | >>>>>>> .r680 |
---|
255 | |
---|
256 | <<<<<<< .mine |
---|
257 | //construit les matrices EQLMN1 & 2 |
---|
258 | |
---|
259 | Calculer_Matrice_LMN(m1, m2, m3); |
---|
260 | ======= |
---|
261 | Calculer_Matrice_LMN(a1, a2, a3); |
---|
262 | >>>>>>> .r680 |
---|
263 | |
---|
264 | <<<<<<< .mine |
---|
265 | for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQLMN1[i][j]=GETLMN[i][j]; |
---|
266 | ======= |
---|
267 | for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQLMN2[i][j]=GETLMN[i][j]; |
---|
268 | >>>>>>> .r680 |
---|
269 | |
---|
270 | Calculer_Matrice_LMN(a1, a2, a3); |
---|
271 | |
---|
272 | for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQLMN2[i][j]=GETLMN[i][j]; |
---|
273 | |
---|
274 | // Calcule le déterminant de EQLMN1 |
---|
275 | |
---|
276 | Det = EQLMN1[1][1] * ((EQLMN1[2][2] * EQLMN1[3][3]) - (EQLMN1[3][2] * EQLMN1[2][ 3])); |
---|
277 | Det = Det - (EQLMN1[1][2] * ((EQLMN1[2][1] * EQLMN1[3][3]) - (EQLMN1[3][1] * EQLMN1[2][3]))); |
---|
278 | Det = Det + (EQLMN1[1][3] * ((EQLMN1[2][1] * EQLMN1[3][2]) - (EQLMN1[3][1] * EQLMN1[2][2]))); |
---|
279 | |
---|
280 | |
---|
281 | // Calcule la matrice inverse EQMI_T de EQLMN1 |
---|
282 | |
---|
283 | if (Det == 0.0) |
---|
284 | { |
---|
285 | ErreurLog("Erreur Matrice_Taki. Impossible de calculer l'inverse de la matrice avec un determinant = 0 \n"); |
---|
286 | return 0; |
---|
287 | } |
---|
288 | else |
---|
289 | { |
---|
290 | EQMI_T[1][1] = ((EQLMN1[2][2] * EQLMN1[3][3]) - (EQLMN1[3][2] * EQLMN1[2][3])) / Det; |
---|
291 | EQMI_T[1][2] = ((EQLMN1[1][3] * EQLMN1[3][2]) - (EQLMN1[1][2] * EQLMN1[3][3])) / Det; |
---|
292 | EQMI_T[1][3] = ((EQLMN1[1][2] * EQLMN1[2][3]) - (EQLMN1[2][2] * EQLMN1[1][3])) / Det; |
---|
293 | EQMI_T[2][1] = ((EQLMN1[2][3] * EQLMN1[3][1]) - (EQLMN1[3][3] * EQLMN1[2][1])) / Det; |
---|
294 | EQMI_T[2][2] = ((EQLMN1[1][1] * EQLMN1[3][3]) - (EQLMN1[3][1] * EQLMN1[1][3])) / Det; |
---|
295 | EQMI_T[2][3] = ((EQLMN1[1][3] * EQLMN1[2][1]) - (EQLMN1[2][3] * EQLMN1[1][1])) / Det; |
---|
296 | EQMI_T[3][1] = ((EQLMN1[2][1] * EQLMN1[3][2]) - (EQLMN1[3][1] * EQLMN1[2][2])) / Det; |
---|
297 | EQMI_T[3][2] = ((EQLMN1[1][2] * EQLMN1[3][1]) - (EQLMN1[3][2] * EQLMN1[1][1])) / Det; |
---|
298 | EQMI_T[3][3] = ((EQLMN1[1][1] * EQLMN1[2][2]) - (EQLMN1[2][1] * EQLMN1[1][2])) / Det; |
---|
299 | } |
---|
300 | |
---|
301 | |
---|
302 | // Effectue le produit des matrices EQMI_T et EQLMN2 |
---|
303 | |
---|
304 | MATRICE[1][1] = (EQMI_T[1][1] * EQLMN2[1][1]) + (EQMI_T[1][2] * EQLMN2[2][1]) + (EQMI_T[1][3] * EQLMN2[3][1]); |
---|
305 | MATRICE[1][2] = (EQMI_T[1][1] * EQLMN2[1][2]) + (EQMI_T[1][2] * EQLMN2[2][2]) + (EQMI_T[1][3] * EQLMN2[3][2]); |
---|
306 | MATRICE[1][3] = (EQMI_T[1][1] * EQLMN2[1][3]) + (EQMI_T[1][2] * EQLMN2[2][3]) + (EQMI_T[1][3] * EQLMN2[3][3]); |
---|
307 | |
---|
308 | MATRICE[2][1] = (EQMI_T[2][1] * EQLMN2[1][1]) + (EQMI_T[2][2] * EQLMN2[2][1]) + (EQMI_T[2][3] * EQLMN2[3][1]); |
---|
309 | MATRICE[2][2] = (EQMI_T[2][1] * EQLMN2[1][2]) + (EQMI_T[2][2] * EQLMN2[2][2]) + (EQMI_T[2][3] * EQLMN2[3][2]); |
---|
310 | MATRICE[2][3] = (EQMI_T[2][1] * EQLMN2[1][3]) + (EQMI_T[2][2] * EQLMN2[2][3]) + (EQMI_T[2][3] * EQLMN2[3][3]); |
---|
311 | |
---|
312 | MATRICE[3][1] = (EQMI_T[3][1] * EQLMN2[1][1]) + (EQMI_T[3][2] * EQLMN2[2][1]) + (EQMI_T[3][3] * EQLMN2[3][1]); |
---|
313 | MATRICE[3][2] = (EQMI_T[3][1] * EQLMN2[1][2]) + (EQMI_T[3][2] * EQLMN2[2][2]) + (EQMI_T[3][3] * EQLMN2[3][2]); |
---|
314 | MATRICE[3][3] = (EQMI_T[3][1] * EQLMN2[1][3]) + (EQMI_T[3][2] * EQLMN2[2][3]) + (EQMI_T[3][3] * EQLMN2[3][3]); |
---|
315 | |
---|
316 | |
---|
317 | // Calcule l'offset sur le ciel |
---|
318 | |
---|
319 | VECT_OFFSET.x = m1.x - ((a1.x * MATRICE[1][1]) + (a1.y * MATRICE[2][1]) + (a1.z * MATRICE[3][1])); |
---|
320 | VECT_OFFSET.y = m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2]) + (a1.z * MATRICE[3][2])); |
---|
321 | VECT_OFFSET.z = m1.z - ((a1.x * MATRICE[1][3]) + (a1.y * MATRICE[2][3]) + (a1.z * MATRICE[3][3])); |
---|
322 | |
---|
323 | |
---|
324 | |
---|
325 | if (x + y == 0 ) |
---|
326 | { |
---|
327 | return 0; |
---|
328 | } |
---|
329 | else |
---|
330 | { |
---|
331 | return PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y); |
---|
332 | } |
---|
333 | } |
---|
334 | |
---|
335 | |
---|
336 | void Alignement::AppliquerMatriceCorrectionTaki(Coord * result, Coord vect) |
---|
337 | { |
---|
338 | // Applique la correction sur le vecteur orientation vect avec |
---|
339 | // vect.x = ascension droite |
---|
340 | // vect.y = déclinaison |
---|
341 | // vect.z = 1 |
---|
342 | |
---|
343 | result->x = -VECT_OFFSET.x + ((vect.x * MATRICE[1][1]) + (vect.y * MATRICE[2][1]) + (vect.z * MATRICE[3][1])); |
---|
344 | result->y = -VECT_OFFSET.y + ((vect.x * MATRICE[1][2]) + (vect.y * MATRICE[2][2]) + (vect.z * MATRICE[3][2])); |
---|
345 | result->z = -VECT_OFFSET.z + ((vect.x * MATRICE[1][3]) + (vect.y * MATRICE[2][3]) + (vect.z * MATRICE[3][3])); |
---|
346 | } |
---|
347 | |
---|
348 | |
---|
349 | |
---|
350 | |
---|
351 | /************************************************************************************** |
---|
352 | ** Matrice intermédiaire nécessaire au calcul de la matrice de correction |
---|
353 | ** dans le mode d'alignement AFFINE |
---|
354 | ** |
---|
355 | ***************************************************************************************/ |
---|
356 | |
---|
357 | void Alignement::Calculer_Matrice_GETPQ(Coord p1, Coord p2, Coord p3) |
---|
358 | { |
---|
359 | GETPQ[1][1] = p2.x - p1.x; |
---|
360 | GETPQ[2][1] = p3.x - p1.x; |
---|
361 | GETPQ[1][2] = p2.y - p1.y; |
---|
362 | GETPQ[2][2] = p3.y - p1.y; |
---|
363 | } |
---|
364 | |
---|
365 | |
---|
366 | |
---|
367 | /************************************************************************************** |
---|
368 | ** Calcul de la matrice de correction dans le mode d'alignement AFFINE |
---|
369 | ** |
---|
370 | ***************************************************************************************/ |
---|
371 | |
---|
372 | int Alignement::Calculer_Matrice_Affine( double x, double y, Coord aa1, Coord aa2, Coord aa3, Coord mm1, Coord mm2, Coord mm3) |
---|
373 | { |
---|
374 | double Det; |
---|
375 | double EQMI[4][4]; |
---|
376 | double EQMP[4][4]; |
---|
377 | double EQMQ[4][4]; |
---|
378 | |
---|
379 | <<<<<<< .mine |
---|
380 | Coord a1, a2, a3, m1, m2, m3, c1, c2; |
---|
381 | ======= |
---|
382 | Coord a1, a2, a3, m1, m2, m3, c1, c2; |
---|
383 | |
---|
384 | AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y); |
---|
385 | AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y); |
---|
386 | AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y); |
---|
387 | |
---|
388 | AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y); |
---|
389 | AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y); |
---|
390 | AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y); |
---|
391 | |
---|
392 | /*c1.x=(a1.x+a2.x+a3.x)/3.0; |
---|
393 | c1.y=(a1.y+a2.y+a3.y)/3.0; |
---|
394 | |
---|
395 | c2.x=(m1.x+m2.x+m3.x)/3.0; |
---|
396 | c2.y=(m1.y+m2.y+m3.y)/3.0; |
---|
397 | |
---|
398 | a1.x-=c1.x; |
---|
399 | a1.y-=c1.y; |
---|
400 | a2.x-=c1.x; |
---|
401 | a2.y-=c1.y; |
---|
402 | a3.x-=c1.x; |
---|
403 | a3.y-=c1.y; |
---|
404 | |
---|
405 | m1.x-=c2.x; |
---|
406 | m1.y-=c2.y; |
---|
407 | m2.x-=c2.x; |
---|
408 | m2.y-=c2.y; |
---|
409 | m3.x-=c2.x; |
---|
410 | m3.y-=c2.y;*/ |
---|
411 | |
---|
412 | |
---|
413 | |
---|
414 | |
---|
415 | //Construit les matrices EQMP et EQMQ |
---|
416 | >>>>>>> .r680 |
---|
417 | |
---|
418 | <<<<<<< .mine |
---|
419 | AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y); |
---|
420 | AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y); |
---|
421 | AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y); |
---|
422 | ======= |
---|
423 | Calculer_Matrice_GETPQ(m1, m2, m3); |
---|
424 | >>>>>>> .r680 |
---|
425 | |
---|
426 | <<<<<<< .mine |
---|
427 | AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y); |
---|
428 | AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y); |
---|
429 | AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y); |
---|
430 | ======= |
---|
431 | for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQMP[i][j]=GETPQ[i][j]; |
---|
432 | >>>>>>> .r680 |
---|
433 | |
---|
434 | <<<<<<< .mine |
---|
435 | |
---|
436 | //Construit les matrices EQMP et EQMQ |
---|
437 | |
---|
438 | Calculer_Matrice_GETPQ(m1, m2, m3); |
---|
439 | ======= |
---|
440 | Calculer_Matrice_GETPQ(a1, a2, a3); |
---|
441 | >>>>>>> .r680 |
---|
442 | |
---|
443 | <<<<<<< .mine |
---|
444 | for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQMP[i][j]=GETPQ[i][j]; |
---|
445 | ======= |
---|
446 | for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQMQ[i][j]=GETPQ[i][j]; |
---|
447 | >>>>>>> .r680 |
---|
448 | |
---|
449 | Calculer_Matrice_GETPQ(a1, a2, a3); |
---|
450 | |
---|
451 | for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQMQ[i][j]=GETPQ[i][j]; |
---|
452 | |
---|
453 | // Calcule l'inverse de EQMP |
---|
454 | |
---|
455 | Det = (EQMP[1][1] * EQMP[2][2]) - (EQMP[1][2] * EQMP[2][1]); |
---|
456 | |
---|
457 | if (Det == 0) |
---|
458 | { |
---|
459 | ErreurLog("Erreur Matrice_Affine. Impossible de calculer l'inverse de la matrice avec un determinant = 0 \n"); |
---|
460 | return 0; |
---|
461 | } |
---|
462 | else |
---|
463 | { |
---|
464 | // Si le déterminant n'est pas nul |
---|
465 | EQMI[1][1] = EQMP[2][2] / Det; |
---|
466 | EQMI[1][2] = -EQMP[1][2] / Det; |
---|
467 | EQMI[2][1] = -EQMP[2][1] / Det; |
---|
468 | EQMI[2][2] = EQMP[1][1] / Det; |
---|
469 | } |
---|
470 | |
---|
471 | |
---|
472 | // MATRICE = EQMI * EQMQ |
---|
473 | |
---|
474 | MATRICE[1][1] = (EQMI[1][1] * EQMQ[1][1]) + (EQMI[1][2] * EQMQ[2][1]); |
---|
475 | MATRICE[1][2] = (EQMI[1][1] * EQMQ[1][2]) + (EQMI[1][2] * EQMQ[2][2]); |
---|
476 | MATRICE[2][1] = (EQMI[2][1] * EQMQ[1][1]) + (EQMI[2][2] * EQMQ[2][1]); |
---|
477 | MATRICE[2][2] = (EQMI[2][1] * EQMQ[1][2]) + (EQMI[2][2] * EQMQ[2][2]); |
---|
478 | |
---|
479 | |
---|
480 | |
---|
481 | |
---|
482 | |
---|
483 | // Calcul du vecteur offset sur le ciel |
---|
484 | |
---|
485 | VECT_OFFSET.x =0.0;//m1.x - ((a1.x * MATRICE[1][1]) + (a1.y * MATRICE[2][1])); |
---|
486 | VECT_OFFSET.y =0.0;//m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2])); |
---|
487 | |
---|
488 | <<<<<<< .mine |
---|
489 | if (x + y == 0 ) |
---|
490 | { |
---|
491 | return 0; |
---|
492 | } |
---|
493 | else |
---|
494 | { |
---|
495 | return PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y); |
---|
496 | } |
---|
497 | ======= |
---|
498 | if (x + y == 0 ) |
---|
499 | { |
---|
500 | return 0; |
---|
501 | } |
---|
502 | else |
---|
503 | { |
---|
504 | return PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y); |
---|
505 | } |
---|
506 | >>>>>>> .r680 |
---|
507 | } |
---|
508 | |
---|
509 | |
---|
510 | |
---|
511 | /************************************************************************************** |
---|
512 | ** Calcule la quantité CoordObjets * MATRICECorrection + VECT_offset |
---|
513 | ** |
---|
514 | ***************************************************************************************/ |
---|
515 | |
---|
516 | void Alignement::AppliquerMatriceCorrectionAffine( Coord * result, Coord ob) |
---|
517 | { |
---|
518 | result->x = VECT_OFFSET.x + ((ob.x * MATRICE[1][1]) + (ob.y * MATRICE[2][1])); |
---|
519 | result->y = VECT_OFFSET.y + ((ob.x * MATRICE[1][2]) + (ob.y * MATRICE[2][2])); |
---|
520 | } |
---|
521 | |
---|
522 | |
---|
523 | inline int Alignement::ElementsMatriceSimple(Coord aa1, Coord aa2, Coord aa3, Coord mm1, Coord mm2, Coord mm3) |
---|
524 | { |
---|
525 | // On se retouvre à devoir résoudre les equations: |
---|
526 | |
---|
527 | // mm1 = aa1 * MATRICE_Correction |
---|
528 | // mm2 = aa2 * MATRICE_Correction |
---|
529 | // mm3 = aa3 * MATRICE_Correction |
---|
530 | |
---|
531 | // et donc à trouver les éléments de la matrice MATRICE_Correction en fonction des paramÚtres x, y, z des vecteurs |
---|
532 | // aa1, aa2, aa3, mm1, mm2, mm3 |
---|
533 | |
---|
534 | // Les éléments de la matrice se trouvent aisément |
---|
535 | |
---|
536 | double div= aa1.z*aa2.y*aa3.x - aa1.y*aa2.z*aa3.x - aa1.z*aa2.x*aa3.y + |
---|
537 | aa1.x*aa2.z*aa3.y + aa1.y*aa2.x*aa3.z - aa1.x*aa2.y*aa3.z; |
---|
538 | |
---|
539 | if ( div !=0.0 ) |
---|
540 | { |
---|
541 | 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 - |
---|
542 | aa1.z*aa2.y*mm3.x + aa1.y*aa2.z*mm3.x)/div); |
---|
543 | |
---|
544 | 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); |
---|
545 | |
---|
546 | 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); |
---|
547 | |
---|
548 | 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 - |
---|
549 | aa1.z*aa2.y*mm3.y + aa1.y*aa2.z*mm3.y)/div); |
---|
550 | |
---|
551 | 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 - |
---|
552 | aa1.x*aa2.z*mm3.y)/div); |
---|
553 | |
---|
554 | 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 - |
---|
555 | aa1.y*aa2.x*mm3.y + aa1.x*aa2.y*mm3.y)/div); |
---|
556 | |
---|
557 | 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 - |
---|
558 | aa1.z*aa2.y*mm3.z + aa1.y*aa2.z*mm3.z)/div); |
---|
559 | |
---|
560 | 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 - |
---|
561 | aa1.x*aa2.z*mm3.z)/div); |
---|
562 | |
---|
563 | 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 - |
---|
564 | aa1.y*aa2.x*mm3.z + aa1.x*aa2.y*mm3.z)/div); |
---|
565 | |
---|
566 | |
---|
567 | |
---|
568 | MATRICE[1][1] = mm11; |
---|
569 | MATRICE[2][1] = mm12; |
---|
570 | MATRICE[3][1] = mm13; |
---|
571 | |
---|
572 | MATRICE[1][2] = mm21; |
---|
573 | MATRICE[2][2] = mm22; |
---|
574 | MATRICE[3][2] = mm23; |
---|
575 | |
---|
576 | MATRICE[1][3] = mm31; |
---|
577 | MATRICE[2][3] = mm32; |
---|
578 | MATRICE[3][3] = mm33; |
---|
579 | |
---|
580 | //Pour vérifs |
---|
581 | //RotationAutourDunAxe(0.3,Pi/2.0-0.1, 0.2); |
---|
582 | |
---|
583 | return 1; |
---|
584 | } |
---|
585 | else |
---|
586 | { |
---|
587 | return 0; |
---|
588 | } |
---|
589 | } |
---|
590 | |
---|
591 | /************************************************************************************** |
---|
592 | ** Calcule la matrice de correction issue de la procédure d'alignement des antennes |
---|
593 | ** |
---|
594 | ** Cette méthode qui utilise trois points de correction seulement est particuliÚrement |
---|
595 | ** simple mais repose sur la qualité des pointages effectués lors de l'alignement sur |
---|
596 | ** les trois étoiles et ne prend en compte de la torsion de la monture etc... |
---|
597 | ** |
---|
598 | ** Les variables a1, a2, a3 contiennent les coordonnées horaires calculées (AD & Dec) des trois |
---|
599 | ** étoiles visées... |
---|
600 | ** Les variables m1, m2, m3 contiennent les coordonnées horaires effectivement mesurées |
---|
601 | ** de ces trois mêmes objets |
---|
602 | ** |
---|
603 | ***************************************************************************************/ |
---|
604 | |
---|
605 | inline int Alignement::Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3) |
---|
606 | { |
---|
607 | double x, y, z; |
---|
608 | |
---|
609 | Coord aa1, aa2, aa3; |
---|
610 | Coord mm1, mm2, mm3; |
---|
611 | |
---|
612 | // Pour chaque variable coordonnées, on calcule d'abord l'azimut et la hauteur de l'objet correspondant |
---|
613 | |
---|
614 | Azimut(a1.x, a1.y, &aa1.x, &aa1.y); |
---|
615 | |
---|
616 | // puis on transforme les coordonnées sphériques (azi, haut) en coordonnées cartésiennes x, y, z |
---|
617 | x=cos(aa1.x) * cos(aa1.y); |
---|
618 | y=sin(aa1.x) * cos(aa1.y); |
---|
619 | z=sin(aa1.y); |
---|
620 | aa1.x=x; |
---|
621 | aa1.y=y; |
---|
622 | aa1.z=z; |
---|
623 | |
---|
624 | Azimut(a2.x, a2.y, &aa2.x, &aa2.y); |
---|
625 | x=cos(aa2.x) * cos(aa2.y); |
---|
626 | y=sin(aa2.x) * cos(aa2.y); |
---|
627 | z=sin(aa2.y); |
---|
628 | aa2.x=x; |
---|
629 | aa2.y=y; |
---|
630 | aa2.z=z; |
---|
631 | |
---|
632 | Azimut(a3.x, a3.y, &aa3.x, &aa3.y); |
---|
633 | x=cos(aa3.x) * cos(aa3.y); |
---|
634 | y=sin(aa3.x) * cos(aa3.y); |
---|
635 | z=sin(aa3.y); |
---|
636 | aa3.x=x; |
---|
637 | aa3.y=y; |
---|
638 | aa3.z=z; |
---|
639 | |
---|
640 | Azimut(m1.x, m1.y, &mm1.x, &mm1.y); |
---|
641 | x=cos(mm1.x) * cos(mm1.y); |
---|
642 | y=sin(mm1.x) * cos(mm1.y); |
---|
643 | z=sin(mm1.y); |
---|
644 | mm1.x=x; |
---|
645 | mm1.y=y; |
---|
646 | mm1.z=z; |
---|
647 | |
---|
648 | Azimut(m2.x, m2.y, &mm2.x, &mm2.y); |
---|
649 | x=cos(mm2.x) * cos(mm2.y); |
---|
650 | y=sin(mm2.x) * cos(mm2.y); |
---|
651 | z=sin(mm2.y); |
---|
652 | mm2.x=x; |
---|
653 | mm2.y=y; |
---|
654 | mm2.z=z; |
---|
655 | |
---|
656 | Azimut(m3.x, m3.y, &mm3.x, &mm3.y); |
---|
657 | x=cos(mm3.x) * cos(mm3.y); |
---|
658 | y=sin(mm3.x) * cos(mm3.y); |
---|
659 | z=sin(mm3.y); |
---|
660 | mm3.x=x; |
---|
661 | mm3.y=y; |
---|
662 | mm3.z=z; |
---|
663 | |
---|
664 | return ElementsMatriceSimple(aa1, aa2, aa3, mm1, mm2, mm3); |
---|
665 | } |
---|
666 | |
---|
667 | |
---|
668 | void Alignement::AppliquerMatriceCorrectionSimple(Coord * result, Coord vect) |
---|
669 | { |
---|
670 | // Applique la correction sur le vecteur orientation vect avec |
---|
671 | |
---|
672 | result->x = vect.x * MATRICE[1][1] + vect.y * MATRICE[2][1] + vect.z * MATRICE[3][1]; |
---|
673 | result->y = vect.x * MATRICE[1][2] + vect.y * MATRICE[2][2] + vect.z * MATRICE[3][2]; |
---|
674 | result->z = vect.x * MATRICE[1][3] + vect.y * MATRICE[2][3] + vect.z * MATRICE[3][3]; |
---|
675 | } |
---|
676 | |
---|
677 | |
---|
678 | <<<<<<< .mine |
---|
679 | double Alignement::Determinant() |
---|
680 | { |
---|
681 | double Det; |
---|
682 | ======= |
---|
683 | double Alignement::Determinant() |
---|
684 | { |
---|
685 | double Det; |
---|
686 | |
---|
687 | Det = MATRICE[1][1] * ((MATRICE[2][2] * MATRICE[3][3]) - (MATRICE[3][2] * MATRICE[2][ 3])); |
---|
688 | Det = Det - (MATRICE[1][2] * ((MATRICE[2][1] * MATRICE[3][3]) - (MATRICE[3][1] * MATRICE[2][3]))); |
---|
689 | Det = Det + (MATRICE[1][3] * ((MATRICE[2][1] * MATRICE[3][2]) - (MATRICE[3][1] * MATRICE[2][2]))); |
---|
690 | >>>>>>> .r680 |
---|
691 | |
---|
692 | <<<<<<< .mine |
---|
693 | Det = MATRICE[1][1] * ((MATRICE[2][2] * MATRICE[3][3]) - (MATRICE[3][2] * MATRICE[2][ 3])); |
---|
694 | Det = Det - (MATRICE[1][2] * ((MATRICE[2][1] * MATRICE[3][3]) - (MATRICE[3][1] * MATRICE[2][3]))); |
---|
695 | Det = Det + (MATRICE[1][3] * ((MATRICE[2][1] * MATRICE[3][2]) - (MATRICE[3][1] * MATRICE[2][2]))); |
---|
696 | ======= |
---|
697 | return Det; |
---|
698 | } |
---|
699 | >>>>>>> .r680 |
---|
700 | |
---|
701 | <<<<<<< .mine |
---|
702 | return Det; |
---|
703 | } |
---|
704 | |
---|
705 | |
---|
706 | |
---|
707 | void Alignement::AzHa2XY(double az, double ha, double *x, double *y) |
---|
708 | { |
---|
709 | double r = Pidiv2 - ha; |
---|
710 | |
---|
711 | *x = r * cos(az); |
---|
712 | |
---|
713 | *y = r * sin(az); |
---|
714 | } |
---|
715 | |
---|
716 | ======= |
---|
717 | |
---|
718 | |
---|
719 | void Alignement::AzHa2XY(double az, double ha, double *x, double *y) |
---|
720 | { |
---|
721 | double r = Pidiv2 - ha; |
---|
722 | |
---|
723 | *x = r * cos(az); |
---|
724 | |
---|
725 | *y = r * sin(az); |
---|
726 | } |
---|
727 | |
---|
728 | >>>>>>> .r680 |
---|
729 | /************************************************************************************** |
---|
730 | ** Calcule la surface d'un triangle de coordonnées (px1,py1) (px2, py2) (px3, py3) |
---|
731 | ** |
---|
732 | ***************************************************************************************/ |
---|
733 | |
---|
734 | double Alignement::Surface_Triangle(double px1, double py1, double px2, double py2, double px3, double py3) |
---|
735 | { |
---|
736 | double ta; |
---|
737 | |
---|
738 | double pxx1, pyy1, pxx2, pyy2, pxx3, pyy3; |
---|
739 | |
---|
740 | <<<<<<< .mine |
---|
741 | double pxx1, pyy1, pxx2, pyy2, pxx3, pyy3; |
---|
742 | ======= |
---|
743 | AzHa2XY(px1, py1, &pxx1, &pyy1); |
---|
744 | >>>>>>> .r680 |
---|
745 | |
---|
746 | <<<<<<< .mine |
---|
747 | AzHa2XY(px1, py1, &pxx1, &pyy1); |
---|
748 | |
---|
749 | AzHa2XY(px2, py2, &pxx2, &pyy2); |
---|
750 | |
---|
751 | AzHa2XY(px3, py3, &pxx3, &pyy3); |
---|
752 | |
---|
753 | ta = (((pxx2 * pyy1) - (pxx1 * pyy2)) ) + (((pxx3 * pyy2) - (pxx2 * pyy3)) ) + (((pxx1 * pyy3) - (pxx3 * pyy1)) ); |
---|
754 | |
---|
755 | ======= |
---|
756 | AzHa2XY(px2, py2, &pxx2, &pyy2); |
---|
757 | |
---|
758 | AzHa2XY(px3, py3, &pxx3, &pyy3); |
---|
759 | |
---|
760 | ta = (((pxx2 * pyy1) - (pxx1 * pyy2)) ) + (((pxx3 * pyy2) - (pxx2 * pyy3)) ) + (((pxx1 * pyy3) - (pxx3 * pyy1)) ); |
---|
761 | |
---|
762 | >>>>>>> .r680 |
---|
763 | return fabs(ta) / 2.0; |
---|
764 | } |
---|
765 | |
---|
766 | |
---|
767 | /************************************************************************************** |
---|
768 | ** Est-ce que le point de coordonnées (px, py) se trouve dans la surface du triangle |
---|
769 | ** de coordonnées (px1,py1) (px2, py2) (px3, py3) ? |
---|
770 | ** |
---|
771 | ***************************************************************************************/ |
---|
772 | |
---|
773 | bool Alignement::PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3) |
---|
774 | { |
---|
775 | double ta; |
---|
776 | double t1; |
---|
777 | double t2; |
---|
778 | double t3; |
---|
779 | |
---|
780 | ta = Surface_Triangle(px1, py1, px2, py2, px3, py3); |
---|
781 | t1 = Surface_Triangle(px, py, px2, py2, px3, py3); |
---|
782 | t2 = Surface_Triangle(px1, py1, px, py, px3, py3); |
---|
783 | t3 = Surface_Triangle(px1, py1, px2, py2, px, py); |
---|
784 | |
---|
785 | stringstream os; |
---|
786 | |
---|
787 | os << fabs(ta - t1 - t2 - t3)<< "\n"; |
---|
788 | AfficherLog(os.str().c_str(), true); |
---|
789 | |
---|
790 | <<<<<<< .mine |
---|
791 | /* if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false; |
---|
792 | if ( DistanceAngulaireEntre2Points(px, py, px2, py2) > 1.2 ) return false; |
---|
793 | if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false;*/ |
---|
794 | ======= |
---|
795 | /* if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false; |
---|
796 | if ( DistanceAngulaireEntre2Points(px, py, px2, py2) > 1.2 ) return false; |
---|
797 | if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false;*/ |
---|
798 | >>>>>>> .r680 |
---|
799 | |
---|
800 | return ( fabs(ta - t1 - t2 - t3) < 1e-10 ); |
---|
801 | } |
---|
802 | |
---|
803 | |
---|
804 | void Alignement::InitParametresInstrument() |
---|
805 | { |
---|
806 | //paramÚtres de l'instrument |
---|
807 | |
---|
808 | ED = ED0; |
---|
809 | CD = CD0; |
---|
810 | BC = BC0; |
---|
811 | AE = AE0; |
---|
812 | I0 = I00; |
---|
813 | Thau = Thau0; |
---|
814 | CoeffMoteur = CoeffMoteur0; |
---|
815 | } |
---|
816 | |
---|
817 | |
---|
818 | double Alignement::Motor2Alt(double pas) |
---|
819 | { |
---|
820 | return asin(( - pow( ( pas * CoeffMoteur0 ) + I00, 2.0 ) + 128279.4) / 129723.4 ) * N180divPi + Thau0; |
---|
821 | } |
---|
822 | |
---|
823 | double Alignement::Alt2Motor(double targetAlt) |
---|
824 | { |
---|
825 | /* double I0 = 81.0; |
---|
826 | |
---|
827 | double I2 = 128279.4 - 129723.4 * sin( (targetAlt - 20.2345) * Pidiv180 ); |
---|
828 | |
---|
829 | double Codalt = (sqrt(I2) - I0) / 0.078947; |
---|
830 | |
---|
831 | AfficherLog("calcul 1 =%5.0f\n", Codalt);*/ |
---|
832 | |
---|
833 | |
---|
834 | |
---|
835 | double CD2pBC2 = CD * CD + BC * BC; |
---|
836 | |
---|
837 | double I2 = -2.0 * ED * sqrt( CD2pBC2 ) * sin( ( targetAlt - Thau ) * Pidiv180 ); |
---|
838 | |
---|
839 | I2 += ED * ED + CD2pBC2 - AE *AE; |
---|
840 | |
---|
841 | double Codalt = ( sqrt(I2) - I0 ) / CoeffMoteur; |
---|
842 | |
---|
843 | // AfficherLog("calcul 2=%5.0f\n", Codalt); |
---|
844 | |
---|
845 | return Codalt; |
---|
846 | } |
---|
847 | |
---|
848 | void Alignement::OptimisationGeometrieAntenne() |
---|
849 | { |
---|
850 | Coord c1, c2, c3, m1, m2, m3, mm1, mm2, mm3, mm; |
---|
851 | |
---|
852 | double i, j, k, l, m; |
---|
853 | |
---|
854 | double memBC = BC0; |
---|
855 | double memCD = CD0; |
---|
856 | double memED = ED0; |
---|
857 | double memAE = AE0; |
---|
858 | // double memI0 = I00; |
---|
859 | double memCoeffMoteur = CoeffMoteur0; |
---|
860 | double memThau = Thau0; |
---|
861 | |
---|
862 | stringstream os; |
---|
863 | |
---|
864 | double det; |
---|
865 | |
---|
866 | double maxdet= 1e50; |
---|
867 | |
---|
868 | double pas = 0.1; |
---|
869 | |
---|
870 | double interv = 0.5; |
---|
871 | |
---|
872 | InitParametresInstrument(); |
---|
873 | |
---|
874 | |
---|
875 | |
---|
876 | c1.x = VerifAngle(ad[0] - tsl[0] + GetTSL()); |
---|
877 | c1.y = de[0]; |
---|
878 | |
---|
879 | Azimut(c1.x, c1.y, &mm.x, &mm.y); |
---|
880 | c1.x = cos(mm.x) * cos(mm.y); |
---|
881 | c1.y = sin(mm.x) * cos(mm.y); |
---|
882 | c1.z = sin(mm.y); |
---|
883 | |
---|
884 | c2.x = VerifAngle(ad[1] - tsl[1] + GetTSL()); |
---|
885 | c2.y = de[1]; |
---|
886 | |
---|
887 | Azimut(c2.x, c2.y, &mm.x, &mm.y); |
---|
888 | c2.x = cos(mm.x) * cos(mm.y); |
---|
889 | c2.y = sin(mm.x) * cos(mm.y); |
---|
890 | c2.z = sin(mm.y); |
---|
891 | |
---|
892 | c3.x = VerifAngle(ad[2] - tsl[2] + GetTSL()); |
---|
893 | c3.y = de[2]; |
---|
894 | |
---|
895 | Azimut(c3.x, c3.y, &mm.x, &mm.y); |
---|
896 | c3.x = cos(mm.x) * cos(mm.y); |
---|
897 | c3.y = sin(mm.x) * cos(mm.y); |
---|
898 | c3.z = sin(mm.y); |
---|
899 | |
---|
900 | m1.x = VerifAngle(delta_ad[0] - tsl[0] + GetTSL()); |
---|
901 | m1.z = 1.0; |
---|
902 | |
---|
903 | m2.x = VerifAngle(delta_ad[1] - tsl[1] + GetTSL()); |
---|
904 | m2.z = 1.0; |
---|
905 | |
---|
906 | m3.x = VerifAngle(delta_ad[2] - tsl[2] + GetTSL()); |
---|
907 | m3.z = 1.0; |
---|
908 | |
---|
909 | |
---|
910 | os << "m1=" << delta_de[0] << " m11=" << Motor2Alt(Alt2Motor(delta_de[0])) << "\n"; |
---|
911 | |
---|
912 | AfficherLog(os.str(), true); |
---|
913 | os.str(""); |
---|
914 | |
---|
915 | for (i=-interv; i< interv; i += pas) |
---|
916 | { |
---|
917 | CoeffMoteur = CoeffMoteur0 + i/100.0; |
---|
918 | |
---|
919 | for (j=-interv; j<interv; j += pas) |
---|
920 | { |
---|
921 | ED = ED0 + j; |
---|
922 | |
---|
923 | for (k=-interv; k<interv; k += pas) |
---|
924 | { |
---|
925 | CD = CD0 + k; |
---|
926 | |
---|
927 | for (l=-interv; l < interv; l+= pas) |
---|
928 | { |
---|
929 | BC = BC0 + l; |
---|
930 | |
---|
931 | Thau = (atan(CD / BC) - atan(18.5 / ED))* N180divPi; |
---|
932 | |
---|
933 | for (m=-interv; m< interv; m += pas) |
---|
934 | { |
---|
935 | AE = AE0 + m; |
---|
936 | |
---|
937 | m1.y = Motor2Alt(Alt2Motor(delta_de[0])); |
---|
938 | |
---|
939 | Azimut(m1.x, m1.y, &mm.x, &mm.y); |
---|
940 | mm1.x = cos(mm.x) * cos(mm.y); |
---|
941 | mm1.y = sin(mm.x) * cos(mm.y); |
---|
942 | mm1.z = sin(mm.y); |
---|
943 | |
---|
944 | m2.y = Motor2Alt(Alt2Motor(delta_de[1])); |
---|
945 | |
---|
946 | Azimut(m2.x, m2.y, &mm.x, &mm.y); |
---|
947 | mm2.x = cos(mm.x) * cos(mm.y); |
---|
948 | mm2.y = sin(mm.x) * cos(mm.y); |
---|
949 | mm2.z = sin(mm.y); |
---|
950 | |
---|
951 | m3.y = Motor2Alt(Alt2Motor(delta_de[2])); |
---|
952 | |
---|
953 | Azimut(m3.x, m3.y, &mm.x, &mm.y); |
---|
954 | mm3.x = cos(mm.x) * cos(mm.y); |
---|
955 | mm3.y = sin(mm.x) * cos(mm.y); |
---|
956 | mm3.z = sin(mm.y); |
---|
957 | |
---|
958 | // Calcul de la matrice de correction en fonction de la méthode d'alignement |
---|
959 | |
---|
960 | Matrice_ok = ElementsMatriceSimple(c1, c2, c3 ,mm1, mm2, mm3); |
---|
961 | |
---|
962 | det = Determinant(); |
---|
963 | |
---|
964 | if (fabs(det - 1.0) < maxdet) |
---|
965 | { |
---|
966 | os << "Determinant=" << det << "\n"; |
---|
967 | |
---|
968 | os << "CD=" << CD << " ED=" << ED << " BC=" << BC << " AE=" << AE << " Thau=" << Thau << " CoeffMoteur=" << CoeffMoteur << "\n\n"; |
---|
969 | |
---|
970 | AfficherLog(os.str(), true); |
---|
971 | os.str(""); |
---|
972 | maxdet = fabs(det - 1.0); |
---|
973 | |
---|
974 | memCD = CD; |
---|
975 | memED = ED; |
---|
976 | memAE = AE; |
---|
977 | memBC = BC; |
---|
978 | memThau = Thau; |
---|
979 | memCoeffMoteur = CoeffMoteur; |
---|
980 | } |
---|
981 | } |
---|
982 | } |
---|
983 | } |
---|
984 | } |
---|
985 | |
---|
986 | AfficherLog("*\n", true); |
---|
987 | } |
---|
988 | |
---|
989 | |
---|
990 | AfficherLog("\n\nFin du calcul.\n", true); |
---|
991 | |
---|
992 | CD = memCD; |
---|
993 | ED = memED; |
---|
994 | AE = memAE; |
---|
995 | BC = memBC; |
---|
996 | Thau = memThau; |
---|
997 | CoeffMoteur = memCoeffMoteur; |
---|
998 | |
---|
999 | m1.y = Motor2Alt(Alt2Motor(delta_de[0])); |
---|
1000 | |
---|
1001 | Azimut(m1.x, m1.y, &mm.x, &mm.y); |
---|
1002 | mm1.x = cos(mm.x) * cos(mm.y); |
---|
1003 | mm1.y = sin(mm.x) * cos(mm.y); |
---|
1004 | mm1.z = sin(mm.y); |
---|
1005 | |
---|
1006 | m2.y = Motor2Alt(Alt2Motor(delta_de[1])); |
---|
1007 | |
---|
1008 | Azimut(m2.x, m2.y, &mm.x, &mm.y); |
---|
1009 | mm2.x = cos(mm.x) * cos(mm.y); |
---|
1010 | mm2.y = sin(mm.x) * cos(mm.y); |
---|
1011 | mm2.z = sin(mm.y); |
---|
1012 | |
---|
1013 | m3.y = Motor2Alt(Alt2Motor(delta_de[2])); |
---|
1014 | |
---|
1015 | Azimut(m3.x, m3.y, &mm.x, &mm.y); |
---|
1016 | mm3.x = cos(mm.x) * cos(mm.y); |
---|
1017 | mm3.y = sin(mm.x) * cos(mm.y); |
---|
1018 | mm3.z = sin(mm.y); |
---|
1019 | |
---|
1020 | // Calcul de la matrice de correction en fonction de la méthode d'alignement |
---|
1021 | |
---|
1022 | Matrice_ok = ElementsMatriceSimple(c1, c2, c3 ,mm1, mm2, mm3); |
---|
1023 | |
---|
1024 | det = Determinant(); |
---|
1025 | |
---|
1026 | |
---|
1027 | |
---|
1028 | os << "Determinant=" << det << "\n"; |
---|
1029 | |
---|
1030 | |
---|
1031 | AfficherLog(os.str(), true); |
---|
1032 | |
---|
1033 | |
---|
1034 | |
---|
1035 | } |
---|
1036 | |
---|
1037 | |
---|
1038 | |
---|
1039 | |
---|
1040 | |
---|
1041 | /************************************************************************************** |
---|
1042 | ** Calcule la matrice de correction issue de la procédure d'alignement des antennes |
---|
1043 | ** |
---|
1044 | ** Routine principale. On construit ici trois vecteurs c1, c2 et c3 qui contiennent |
---|
1045 | ** les coordonnées (issues du catalogue) de trois objets visés pendant la procédure |
---|
1046 | ** d'alignement. Les vecteurs m1, m2 et m3 contiennent les coordonnées mesurées |
---|
1047 | ** de ces mêmes objets dans le viseur de l'instrument. |
---|
1048 | ** |
---|
1049 | ***************************************************************************************/ |
---|
1050 | |
---|
1051 | void Alignement::CalculerMatriceCorrection(double ar, double dec) |
---|
1052 | { |
---|
1053 | Coord c1, c2, c3, m1, m2, m3; |
---|
1054 | |
---|
1055 | double a1, b1, a2, b2, a3, b3, a4, b4, a5, b5; |
---|
1056 | |
---|
1057 | int map[MAXALIGNEMENTANTENNE]; |
---|
1058 | |
---|
1059 | stringstream os; |
---|
1060 | |
---|
1061 | int best1 = -1; |
---|
1062 | int best2 = -1; |
---|
1063 | int best3 = -1; |
---|
1064 | |
---|
1065 | |
---|
1066 | // On calcule le temps sidéral local, etc... |
---|
1067 | |
---|
1068 | CalculTSL(); |
---|
1069 | |
---|
1070 | switch ( MethodeAlignement ) |
---|
1071 | { |
---|
1072 | case SIMPLE : |
---|
1073 | { |
---|
1074 | best1 = 0; |
---|
1075 | best2 = 1; |
---|
1076 | best3 = 2; |
---|
1077 | |
---|
1078 | for (int i=0; i<MAXALIGNEMENTANTENNE; i++) map[i] = i; |
---|
1079 | } |
---|
1080 | break; |
---|
1081 | |
---|
1082 | |
---|
1083 | case AFFINE: |
---|
1084 | case TAKI : |
---|
1085 | { |
---|
1086 | double *distances; |
---|
1087 | |
---|
1088 | distances = new double [nbrcorrections+1]; |
---|
1089 | |
---|
1090 | os << "Coordonnées visees : ad=" << DHMS(ar * 15.0,true) << " de=" << DHMS(dec,false) << "\n"; |
---|
1091 | |
---|
1092 | Azimut(ar * 15.0 * Pidiv180, dec * Pidiv180, &a2, &b2); |
---|
1093 | |
---|
1094 | for (int i=0; i<nbrcorrections; i++) |
---|
1095 | { |
---|
1096 | Azimut(VerifAngle(ad[i]- tsl[i] + GetTSL() ),de[i], &a1, &b1); |
---|
1097 | |
---|
1098 | distances[i] = DistanceAngulaireEntre2Points(a1, b1, a2, b2); |
---|
1099 | |
---|
1100 | map[i]=i; |
---|
1101 | } |
---|
1102 | |
---|
1103 | for (int i=0; i<nbrcorrections; i++) |
---|
1104 | { |
---|
1105 | for (int j=i+1; j<nbrcorrections; j++) |
---|
1106 | { |
---|
1107 | if ( distances[j] < distances[i] ) |
---|
1108 | { |
---|
1109 | double bout = distances[i]; |
---|
1110 | distances[i] = distances[j]; |
---|
1111 | distances[j] = bout; |
---|
1112 | |
---|
1113 | int bout2 = map[i]; |
---|
1114 | map[i] = map[j]; |
---|
1115 | map[j] = bout2; |
---|
1116 | } |
---|
1117 | } |
---|
1118 | } |
---|
1119 | |
---|
1120 | for (int i=0; i<nbrcorrections; i++) |
---|
1121 | { |
---|
1122 | os << "Point " << map[i] << " d=" << distances[i] * N180divPi << "°\n"; |
---|
1123 | } |
---|
1124 | <<<<<<< .mine |
---|
1125 | |
---|
1126 | for (int i=0; i<nbrcorrections; i++) |
---|
1127 | ======= |
---|
1128 | |
---|
1129 | for (int i=0; i<nbrcorrections; i++) |
---|
1130 | >>>>>>> .r680 |
---|
1131 | { |
---|
1132 | for (int j=i+1; j<nbrcorrections; j++) |
---|
1133 | { |
---|
1134 | for (int k=j+1; k<nbrcorrections; k++) |
---|
1135 | { |
---|
1136 | os << "Triangle : " << map[i] << " " << map[j] << " " << map[k] << "\n"; |
---|
1137 | |
---|
1138 | os << "Objet "; |
---|
1139 | |
---|
1140 | os << ": az=" << DHMS(a2*N180divPi, false) << " ha=" << DHMS(b2*N180divPi, false) << "\n"; |
---|
1141 | |
---|
1142 | os << "Etoile " << map[i] ; |
---|
1143 | |
---|
1144 | Azimut(VerifAngle(ad[map[i]] - tsl[map[i]] + GetTSL()), de[map[i]], &a3, &b3); |
---|
1145 | |
---|
1146 | os << ": az=" << DHMS(a3*N180divPi, false) << " ha=" << DHMS(b3*N180divPi, false) << "\n"; |
---|
1147 | |
---|
1148 | os << "Etoile " << map[j] ; |
---|
1149 | |
---|
1150 | Azimut(VerifAngle(ad[map[j]] - tsl[map[j]] + GetTSL()), de[map[j]], &a4, &b4); |
---|
1151 | |
---|
1152 | os << ": az=" << DHMS(a4*N180divPi, false) << " ha=" << DHMS(b4*N180divPi, false) << "\n"; |
---|
1153 | |
---|
1154 | os << "Etoile " << map[k] ; |
---|
1155 | |
---|
1156 | Azimut(VerifAngle(ad[map[k]] - tsl[map[k]] + GetTSL()), de[map[k]], &a5, &b5); |
---|
1157 | |
---|
1158 | os << ": az=" << DHMS(a5*N180divPi, false) << " ha=" << DHMS(b5*N180divPi, false) << "\n"; |
---|
1159 | |
---|
1160 | AfficherLog(&os, true); |
---|
1161 | |
---|
1162 | if (PointSitueDansSurfaceTriangle(a2, b2, |
---|
1163 | a3, b3, |
---|
1164 | a4, b4, |
---|
1165 | a5, b5)) |
---|
1166 | { |
---|
1167 | best1=i; |
---|
1168 | best2=j; |
---|
1169 | best3=k; |
---|
1170 | k=1000; |
---|
1171 | j=1000; |
---|
1172 | i=1000; |
---|
1173 | } |
---|
1174 | } |
---|
1175 | } |
---|
1176 | } |
---|
1177 | |
---|
1178 | delete [] distances; |
---|
1179 | } |
---|
1180 | break; |
---|
1181 | } |
---|
1182 | |
---|
1183 | |
---|
1184 | |
---|
1185 | if ( best1 == -1 && best2 == -1 && best3 == -1 ) |
---|
1186 | { |
---|
1187 | if (MethodeAlignement == AFFINE || MethodeAlignement == TAKI) |
---|
1188 | { |
---|
1189 | ErreurLog("Erreur ! Pas de triangle disponible pour la correction !\nLe positionnement de l antenne sera approximatif !\n"); |
---|
1190 | } |
---|
1191 | |
---|
1192 | Identity(); |
---|
1193 | |
---|
1194 | Matrice_ok = false; |
---|
1195 | |
---|
1196 | return; |
---|
1197 | } |
---|
1198 | else |
---|
1199 | { |
---|
1200 | os << "\nUtilisation du triangle : " << map[best1] << " " << map[best2] << " " << map[best3] << "\n" ; |
---|
1201 | |
---|
1202 | <<<<<<< .mine |
---|
1203 | // if (MethodeAlignement == SIMPLE) |
---|
1204 | ======= |
---|
1205 | // if (MethodeAlignement == SIMPLE) |
---|
1206 | >>>>>>> .r680 |
---|
1207 | { |
---|
1208 | c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL()); |
---|
1209 | c1.y = de[map[best1]]; |
---|
1210 | c1.z = 1.0; |
---|
1211 | |
---|
1212 | c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL()); |
---|
1213 | c2.y = de[map[best2]]; |
---|
1214 | c2.z = 1.0; |
---|
1215 | |
---|
1216 | c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL()); |
---|
1217 | c3.y = de[map[best3]]; |
---|
1218 | c3.z = 1.0; |
---|
1219 | } |
---|
1220 | <<<<<<< .mine |
---|
1221 | /* else |
---|
1222 | { |
---|
1223 | c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL()); |
---|
1224 | c1.y = de[map[best1]]; |
---|
1225 | c1.z = 1.0; |
---|
1226 | ======= |
---|
1227 | /* else |
---|
1228 | { |
---|
1229 | c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL()); |
---|
1230 | c1.y = de[map[best1]]; |
---|
1231 | c1.z = 1.0; |
---|
1232 | >>>>>>> .r680 |
---|
1233 | |
---|
1234 | <<<<<<< .mine |
---|
1235 | c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL()); |
---|
1236 | c2.y = de[map[best2]]; |
---|
1237 | c2.z = 1.0; |
---|
1238 | ======= |
---|
1239 | c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL()); |
---|
1240 | c2.y = de[map[best2]]; |
---|
1241 | c2.z = 1.0; |
---|
1242 | >>>>>>> .r680 |
---|
1243 | |
---|
1244 | <<<<<<< .mine |
---|
1245 | c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL()); |
---|
1246 | c3.y = de[map[best3]]; |
---|
1247 | c3.z = 1.0; |
---|
1248 | }*/ |
---|
1249 | |
---|
1250 | m1.x = VerifAngle(delta_ad[map[best1]] - tsl[map[best1]] + GetTSL()); |
---|
1251 | m1.y = delta_de[map[best1]]; |
---|
1252 | ======= |
---|
1253 | c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL()); |
---|
1254 | c3.y = de[map[best3]]; |
---|
1255 | c3.z = 1.0; |
---|
1256 | }*/ |
---|
1257 | |
---|
1258 | m1.x = VerifAngle(delta_ad[map[best1]] - tsl[map[best1]] + GetTSL()); |
---|
1259 | m1.y = delta_de[map[best1]]; |
---|
1260 | >>>>>>> .r680 |
---|
1261 | m1.z = 1.0; |
---|
1262 | |
---|
1263 | m2.x = VerifAngle(delta_ad[map[best2]] - tsl[map[best2]] + GetTSL()); |
---|
1264 | m2.y = delta_de[map[best2]]; |
---|
1265 | m2.z = 1.0; |
---|
1266 | |
---|
1267 | m3.x = VerifAngle(delta_ad[map[best3]] - tsl[map[best3]] + GetTSL()); |
---|
1268 | m3.y = delta_de[map[best3]]; |
---|
1269 | m3.z = 1.0; |
---|
1270 | } |
---|
1271 | |
---|
1272 | // Calcul de la matrice de correction en fonction de la méthode d'alignement |
---|
1273 | |
---|
1274 | switch (MethodeAlignement) |
---|
1275 | { |
---|
1276 | case SIMPLE: |
---|
1277 | os << "Methode d alignement SIMPLE\n"; |
---|
1278 | Matrice_ok = Calculer_Matrice_Simple(c1, c2, c3 ,m1, m2, m3); |
---|
1279 | break; |
---|
1280 | case AFFINE: |
---|
1281 | os << "Methode d alignement AFFINE\n"; |
---|
1282 | Matrice_ok = Calculer_Matrice_Affine( VerifAngle( ar * 15.0 * Pidiv180 ), dec * Pidiv180, c1, c2, c3 ,m1, m2, m3); |
---|
1283 | break; |
---|
1284 | case TAKI: |
---|
1285 | os << "Methode d alignement TAKI\n"; |
---|
1286 | Matrice_ok = Calculer_Matrice_Taki ( VerifAngle( ar * 15.0 * Pidiv180 ), dec * Pidiv180, c1, c2, c3 ,m1, m2, m3); |
---|
1287 | break; |
---|
1288 | } |
---|
1289 | |
---|
1290 | |
---|
1291 | // Affiche de la matrice pour vérif |
---|
1292 | |
---|
1293 | os << "\nCalcul de la matrice de correction:\n"; |
---|
1294 | os << MATRICE[1][1] << " \t" << MATRICE[2][1] << " \t" << MATRICE[3][1] << "\n"; |
---|
1295 | os << MATRICE[1][2] << " \t" << MATRICE[2][2] << " \t" << MATRICE[3][2] << "\n"; |
---|
1296 | os << MATRICE[1][3] << " \t" << MATRICE[2][3] << " \t" << MATRICE[3][3] << "\n"; |
---|
1297 | os << "\nDeterminant :" << Determinant() << "\n"; |
---|
1298 | |
---|
1299 | |
---|
1300 | <<<<<<< .mine |
---|
1301 | for (int i=0; i<nbrcorrections; i++) SelectionnePourCalculMatrice[i] = false; |
---|
1302 | ======= |
---|
1303 | for (int i=0; i<nbrcorrections; i++) SelectionnePourCalculMatrice[i] = false; |
---|
1304 | |
---|
1305 | SelectionnePourCalculMatrice[map[best1]] = true; |
---|
1306 | SelectionnePourCalculMatrice[map[best2]] = true; |
---|
1307 | SelectionnePourCalculMatrice[map[best3]] = true; |
---|
1308 | |
---|
1309 | >>>>>>> .r680 |
---|
1310 | |
---|
1311 | <<<<<<< .mine |
---|
1312 | SelectionnePourCalculMatrice[map[best1]] = true; |
---|
1313 | SelectionnePourCalculMatrice[map[best2]] = true; |
---|
1314 | SelectionnePourCalculMatrice[map[best3]] = true; |
---|
1315 | |
---|
1316 | |
---|
1317 | ======= |
---|
1318 | //Vérifications supp |
---|
1319 | /* |
---|
1320 | Coord result, mm1; |
---|
1321 | double targetAz, targetAlt; |
---|
1322 | |
---|
1323 | os << "\n\n\n" << GetLatitude()*N180divPi << " " << GetLongitude()*N180divPi << "\n"; |
---|
1324 | os << GetPression() << " " << GetTemperature() << "\n"; |
---|
1325 | os << GetHeure() << ":" << GetMin() << ":" << GetSec() << "\n"; |
---|
1326 | os << DHMS(GetTSL()*N180divPi, true) << "\n\n"; |
---|
1327 | |
---|
1328 | Azimut(c3.x, c3.y, &mm1.x, &mm1.y); |
---|
1329 | |
---|
1330 | os << mm1.x*N180divPi << " " << mm1.y*N180divPi << "\n"; |
---|
1331 | |
---|
1332 | |
---|
1333 | Azimut(m3.x, m3.y, &mm1.x, &mm1.y); |
---|
1334 | |
---|
1335 | os << mm1.x*N180divPi << " " << mm1.y*N180divPi << "\n"; |
---|
1336 | |
---|
1337 | |
---|
1338 | Azimut(c3.x, c3.y, &mm1.x, &mm1.y); |
---|
1339 | |
---|
1340 | double x=cos(mm1.x) * cos(mm1.y); |
---|
1341 | double y=sin(mm1.x) * cos(mm1.y); |
---|
1342 | double z=sin(mm1.y); |
---|
1343 | mm1.x=x; |
---|
1344 | mm1.y=y; |
---|
1345 | mm1.z=z; |
---|
1346 | |
---|
1347 | AppliquerMatriceCorrectionSimple(&result, mm1); |
---|
1348 | |
---|
1349 | if (result.x != 0.0) |
---|
1350 | { |
---|
1351 | targetAz = atan( result.y / result.x ); |
---|
1352 | |
---|
1353 | if (result.x < 0) targetAz+=Pi; |
---|
1354 | } |
---|
1355 | else targetAz = Pidiv2; |
---|
1356 | |
---|
1357 | targetAz = VerifAngle(targetAz); |
---|
1358 | |
---|
1359 | targetAlt = asin(result.z); |
---|
1360 | |
---|
1361 | os << targetAz*N180divPi << " " << targetAlt*N180divPi << "\n"; |
---|
1362 | */ |
---|
1363 | |
---|
1364 | |
---|
1365 | |
---|
1366 | >>>>>>> .r680 |
---|
1367 | //Afficher les messages de cette fonction |
---|
1368 | |
---|
1369 | AfficherLog(os.str(), true); |
---|
1370 | } |
---|
1371 | |
---|
1372 | |
---|
1373 | |
---|
1374 | /************************************************************************************** |
---|
1375 | ** Le fichier file existe-t-il et n'est-il pas vide ? |
---|
1376 | **************************************************************************************/ |
---|
1377 | |
---|
1378 | bool Alignement::is_readable( const std::string & file ) |
---|
1379 | { |
---|
1380 | std::ifstream fichier( file.c_str() ); |
---|
1381 | if (fichier.fail()) return false; |
---|
1382 | |
---|
1383 | // sauvegarder la position courante |
---|
1384 | <<<<<<< .mine |
---|
1385 | // long pos = fichier.tellg(); |
---|
1386 | ======= |
---|
1387 | // long pos = fichier.tellg(); |
---|
1388 | >>>>>>> .r680 |
---|
1389 | // se placer en fin de fichier |
---|
1390 | fichier.seekg( 0 , std::ios_base::end ); |
---|
1391 | // récupérer la nouvelle position = la taille du fichier |
---|
1392 | long size = fichier.tellg(); |
---|
1393 | return (size > 0); |
---|
1394 | } |
---|
1395 | |
---|
1396 | |
---|
1397 | /************************************************************************************** |
---|
1398 | ** Chargement des paramÚtres d'alignement des antennes |
---|
1399 | **************************************************************************************/ |
---|
1400 | |
---|
1401 | bool Alignement::ChargementParametresAlignement(string IP, string fileName, double a, double b) |
---|
1402 | { |
---|
1403 | static double mema = a; |
---|
1404 | |
---|
1405 | static double memb = b; |
---|
1406 | |
---|
1407 | string value; |
---|
1408 | |
---|
1409 | stringstream os, os2; |
---|
1410 | |
---|
1411 | char *delta_az = NULL; |
---|
1412 | |
---|
1413 | char *delta_ha = NULL; |
---|
1414 | |
---|
1415 | char *ad_data = NULL; |
---|
1416 | |
---|
1417 | char *de_data = NULL; |
---|
1418 | |
---|
1419 | char *delta_ad_data = NULL; |
---|
1420 | |
---|
1421 | char *delta_de_data = NULL; |
---|
1422 | |
---|
1423 | char *align_data = NULL; |
---|
1424 | |
---|
1425 | char *alignment_method_data = NULL; |
---|
1426 | |
---|
1427 | char *tsl_data = NULL; |
---|
1428 | |
---|
1429 | if (!is_readable(fileName)) return false; |
---|
1430 | |
---|
1431 | // Chargement des corrections des antennes |
---|
1432 | |
---|
1433 | bool modificationAlignement = false; |
---|
1434 | |
---|
1435 | // On sélectionne la bonne antenne (à partir de son adresse ip). |
---|
1436 | |
---|
1437 | os << "Alignement antenne ip " << IP; |
---|
1438 | |
---|
1439 | |
---|
1440 | <<<<<<< .mine |
---|
1441 | nbrcorrections = 0; |
---|
1442 | |
---|
1443 | for (int j=0; j < MAXALIGNEMENTANTENNE; j++) |
---|
1444 | ======= |
---|
1445 | nbrcorrections = 0; |
---|
1446 | |
---|
1447 | for (int j=0; j < MAXALIGNEMENTANTENNE; j++) |
---|
1448 | >>>>>>> .r680 |
---|
1449 | { |
---|
1450 | os2 << "ad " << j; |
---|
1451 | |
---|
1452 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &ad_data, (char*)fileName.c_str()); |
---|
1453 | |
---|
1454 | os2.str(""); |
---|
1455 | |
---|
1456 | os2 << "de " << j; |
---|
1457 | |
---|
1458 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &de_data, (char*)fileName.c_str()); |
---|
1459 | |
---|
1460 | os2.str(""); |
---|
1461 | |
---|
1462 | os2 << "delta_ad " << j; |
---|
1463 | |
---|
1464 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_ad_data, (char*)fileName.c_str()); |
---|
1465 | |
---|
1466 | os2.str(""); |
---|
1467 | |
---|
1468 | os2 << "delta_de " << j; |
---|
1469 | |
---|
1470 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_de_data, (char*)fileName.c_str()); |
---|
1471 | |
---|
1472 | os2.str(""); |
---|
1473 | |
---|
1474 | os2 << "tsl " << j; |
---|
1475 | |
---|
1476 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &tsl_data, (char*)fileName.c_str()); |
---|
1477 | |
---|
1478 | os2.str(""); |
---|
1479 | |
---|
1480 | |
---|
1481 | if ( ad_data && de_data && delta_ad_data && delta_de_data |
---|
1482 | && tsl_data && atof(tsl_data)!=0.0 && atof(ad_data)!=0.0 && atof(de_data)!=0.0) |
---|
1483 | { |
---|
1484 | // Si les corrections de l'antenne i ont été modifiées depuis le démarrage du programme |
---|
1485 | // -> on les applique... |
---|
1486 | |
---|
1487 | <<<<<<< .mine |
---|
1488 | ======= |
---|
1489 | |
---|
1490 | >>>>>>> .r680 |
---|
1491 | |
---|
1492 | <<<<<<< .mine |
---|
1493 | |
---|
1494 | if (delta_ad[nbrcorrections] != atof(delta_ad_data) || delta_de[nbrcorrections] != atof(delta_de_data)) |
---|
1495 | ======= |
---|
1496 | if (delta_ad[nbrcorrections] != atof(delta_ad_data) || delta_de[nbrcorrections] != atof(delta_de_data)) |
---|
1497 | >>>>>>> .r680 |
---|
1498 | { |
---|
1499 | ad[nbrcorrections] = atof(ad_data); |
---|
1500 | |
---|
1501 | de[nbrcorrections] = atof(de_data); |
---|
1502 | |
---|
1503 | delta_ad[nbrcorrections] = atof(delta_ad_data); |
---|
1504 | |
---|
1505 | delta_de[nbrcorrections] = atof(delta_de_data); |
---|
1506 | |
---|
1507 | tsl[nbrcorrections] = atof(tsl_data); |
---|
1508 | |
---|
1509 | <<<<<<< .mine |
---|
1510 | os2 << "Correction antenne ip=" << IP << " ad=" << ad[nbrcorrections] << " de=" << de[nbrcorrections] << " deltaAD=" << |
---|
1511 | delta_ad[nbrcorrections] << " deltaDe=" << delta_de[nbrcorrections] << " tsl=" << tsl[nbrcorrections] << "\n"; |
---|
1512 | ======= |
---|
1513 | os2 << "Correction antenne ip=" << IP << " ad=" << ad[nbrcorrections] << " de=" << de[nbrcorrections] << " deltaAD=" << |
---|
1514 | delta_ad[nbrcorrections] << " deltaDe=" << delta_de[nbrcorrections] << " tsl=" << tsl[nbrcorrections] << "\n"; |
---|
1515 | >>>>>>> .r680 |
---|
1516 | |
---|
1517 | AfficherLog(&os2, true); |
---|
1518 | |
---|
1519 | modificationAlignement = true; |
---|
1520 | <<<<<<< .mine |
---|
1521 | |
---|
1522 | nbrcorrections++; |
---|
1523 | } |
---|
1524 | ======= |
---|
1525 | |
---|
1526 | nbrcorrections++; |
---|
1527 | } |
---|
1528 | >>>>>>> .r680 |
---|
1529 | } |
---|
1530 | |
---|
1531 | SAFEDELETE_TAB(ad_data); |
---|
1532 | |
---|
1533 | SAFEDELETE_TAB(de_data); |
---|
1534 | |
---|
1535 | SAFEDELETE_TAB(delta_ad_data); |
---|
1536 | |
---|
1537 | SAFEDELETE_TAB(delta_de_data); |
---|
1538 | |
---|
1539 | SAFEDELETE_TAB(tsl_data); |
---|
1540 | } |
---|
1541 | |
---|
1542 | os2 << "delta_az"; |
---|
1543 | |
---|
1544 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_az, (char*)fileName.c_str()); |
---|
1545 | |
---|
1546 | os2.str(""); |
---|
1547 | |
---|
1548 | if (delta_az) |
---|
1549 | { |
---|
1550 | if ( deltaAZ != atol(delta_az) ) |
---|
1551 | { |
---|
1552 | deltaAZ = atol(delta_az); |
---|
1553 | |
---|
1554 | modificationAlignement = true; |
---|
1555 | } |
---|
1556 | } |
---|
1557 | |
---|
1558 | os2 << "delta_ha"; |
---|
1559 | |
---|
1560 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_ha, (char*)fileName.c_str()); |
---|
1561 | |
---|
1562 | os2.str(""); |
---|
1563 | |
---|
1564 | if (delta_ha) |
---|
1565 | { |
---|
1566 | if ( deltaHA != atol(delta_ha) ) |
---|
1567 | { |
---|
1568 | deltaHA= atol(delta_ha); |
---|
1569 | |
---|
1570 | modificationAlignement = true; |
---|
1571 | } |
---|
1572 | } |
---|
1573 | |
---|
1574 | os2 << "alignment_method"; |
---|
1575 | |
---|
1576 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &alignment_method_data, (char*)fileName.c_str()); |
---|
1577 | |
---|
1578 | os2.str(""); |
---|
1579 | |
---|
1580 | if (alignment_method_data) |
---|
1581 | { |
---|
1582 | if ( MethodeAlignement != atoi(alignment_method_data) ) |
---|
1583 | { |
---|
1584 | MethodeAlignement = atoi(alignment_method_data); |
---|
1585 | |
---|
1586 | modificationAlignement = true; |
---|
1587 | } |
---|
1588 | } |
---|
1589 | |
---|
1590 | os2 << "align"; |
---|
1591 | |
---|
1592 | readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &align_data, (char*)fileName.c_str()); |
---|
1593 | |
---|
1594 | os2.str(""); |
---|
1595 | |
---|
1596 | |
---|
1597 | if (align_data) |
---|
1598 | { |
---|
1599 | // Si la procédure d'alignement se termine, il faut calculer la matrice de correction |
---|
1600 | |
---|
1601 | if (AlignementEnCours != atoi(align_data)) |
---|
1602 | { |
---|
1603 | AlignementEnCours = atoi(align_data); |
---|
1604 | |
---|
1605 | modificationAlignement = true; |
---|
1606 | } |
---|
1607 | } |
---|
1608 | |
---|
1609 | if (mema!=a || memb!=b) |
---|
1610 | { |
---|
1611 | mema = a; |
---|
1612 | |
---|
1613 | memb = b; |
---|
1614 | |
---|
1615 | modificationAlignement = true; |
---|
1616 | } |
---|
1617 | |
---|
1618 | // si nbrcorrections=0 (suite à l'utilisation de la commande reset dans BAOcontrol par ex) il faut |
---|
1619 | // réinitialiser la matrice |
---|
1620 | |
---|
1621 | if (nbrcorrections == 0 ) modificationAlignement = true; |
---|
1622 | |
---|
1623 | |
---|
1624 | // Si un des paramÚtres d'une antenne change pendant la procédure d'alignement ou que l'on a |
---|
1625 | // plus de deux points d'alignement sur une antenne, alors on calcule la matrice de correction |
---|
1626 | |
---|
1627 | if (modificationAlignement) |
---|
1628 | { |
---|
1629 | if (nbrcorrections >=3 && AlignementEnCours == 0) |
---|
1630 | { |
---|
1631 | // IDLog("Calcul matrice\n", true); |
---|
1632 | CalculerMatriceCorrection(a, b); |
---|
1633 | } |
---|
1634 | else |
---|
1635 | { |
---|
1636 | Identity(); |
---|
1637 | |
---|
1638 | Matrice_ok = false; |
---|
1639 | } |
---|
1640 | } |
---|
1641 | |
---|
1642 | SAFEDELETE_TAB(delta_az); |
---|
1643 | |
---|
1644 | SAFEDELETE_TAB(delta_ha); |
---|
1645 | |
---|
1646 | SAFEDELETE_TAB(alignment_method_data); |
---|
1647 | |
---|
1648 | SAFEDELETE_TAB(align_data); |
---|
1649 | |
---|
1650 | return true; |
---|
1651 | } |
---|
1652 | |
---|
1653 | |
---|
1654 | |
---|
1655 | /************************************************************************************** |
---|
1656 | ** Sauvegarde des paramÚtres d'alignement des antennes |
---|
1657 | ***************************************************************************************/ |
---|
1658 | |
---|
1659 | bool Alignement::EnregistrementParametresAlignement(string IP, string fileName) |
---|
1660 | { |
---|
1661 | string section; |
---|
1662 | string key; |
---|
1663 | string value; |
---|
1664 | |
---|
1665 | stringstream os; |
---|
1666 | |
---|
1667 | |
---|
1668 | //AfficherLog("Enregistrement de l'alignement des antennes dans le fichier " + fileName + "\n", true); |
---|
1669 | |
---|
1670 | //Enregistrement des corrections des l'antennes |
---|
1671 | |
---|
1672 | |
---|
1673 | os << "Alignement antenne ip " << IP; |
---|
1674 | section = os.str(); |
---|
1675 | os.str(""); |
---|
1676 | |
---|
1677 | os << "align"; |
---|
1678 | key = os.str(); |
---|
1679 | os.str(""); |
---|
1680 | (AlignementEnCours == true) ? os << "1" : os << "0"; |
---|
1681 | value = os.str(); |
---|
1682 | os.str(""); |
---|
1683 | |
---|
1684 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1685 | |
---|
1686 | os << "alignment_method"; |
---|
1687 | key = os.str(); |
---|
1688 | os.str(""); |
---|
1689 | os << MethodeAlignement; |
---|
1690 | value = os.str(); |
---|
1691 | os.str(""); |
---|
1692 | |
---|
1693 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1694 | |
---|
1695 | os << "delta_az"; |
---|
1696 | key = os.str(); |
---|
1697 | os.str(""); |
---|
1698 | os << deltaAZ; |
---|
1699 | value = os.str(); |
---|
1700 | os.str(""); |
---|
1701 | |
---|
1702 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1703 | |
---|
1704 | os << "delta_ha"; |
---|
1705 | key = os.str(); |
---|
1706 | os.str(""); |
---|
1707 | os << deltaHA; |
---|
1708 | value = os.str(); |
---|
1709 | os.str(""); |
---|
1710 | |
---|
1711 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1712 | |
---|
1713 | |
---|
1714 | for (int j = 0; j < MAXALIGNEMENTANTENNE; j++) |
---|
1715 | { |
---|
1716 | os << "ad " << j; |
---|
1717 | key = os.str(); |
---|
1718 | os.str(""); |
---|
1719 | os << 0.0; |
---|
1720 | value = os.str(); |
---|
1721 | os.str(""); |
---|
1722 | |
---|
1723 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1724 | |
---|
1725 | os << "de " << j; |
---|
1726 | key = os.str(); |
---|
1727 | os.str(""); |
---|
1728 | os << 0.0; |
---|
1729 | value = os.str(); |
---|
1730 | os.str(""); |
---|
1731 | |
---|
1732 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1733 | |
---|
1734 | os << "delta_ad " << j; |
---|
1735 | key = os.str(); |
---|
1736 | os.str(""); |
---|
1737 | os << 0.0; |
---|
1738 | value = os.str(); |
---|
1739 | os.str(""); |
---|
1740 | |
---|
1741 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1742 | |
---|
1743 | os << "delta_de " << j; |
---|
1744 | key = os.str(); |
---|
1745 | os.str(""); |
---|
1746 | os << 0.0; |
---|
1747 | value = os.str(); |
---|
1748 | os.str(""); |
---|
1749 | |
---|
1750 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1751 | |
---|
1752 | os << "tsl " << j; |
---|
1753 | key = os.str(); |
---|
1754 | os.str(""); |
---|
1755 | os << 0.0; |
---|
1756 | value = os.str(); |
---|
1757 | os.str(""); |
---|
1758 | |
---|
1759 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1760 | } |
---|
1761 | |
---|
1762 | <<<<<<< .mine |
---|
1763 | for (int j = 0; j < nbrcorrections; j++) if (ad[j]!=0.0 && de[j]!=0.0) |
---|
1764 | { |
---|
1765 | os << "ad " << j; |
---|
1766 | key = os.str(); |
---|
1767 | os.str(""); |
---|
1768 | os << ad[j]; |
---|
1769 | value = os.str(); |
---|
1770 | os.str(""); |
---|
1771 | |
---|
1772 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1773 | ======= |
---|
1774 | for (int j = 0; j < nbrcorrections; j++) if (ad[j]!=0.0 && de[j]!=0.0) |
---|
1775 | { |
---|
1776 | os << "ad " << j; |
---|
1777 | key = os.str(); |
---|
1778 | os.str(""); |
---|
1779 | os << ad[j]; |
---|
1780 | value = os.str(); |
---|
1781 | os.str(""); |
---|
1782 | >>>>>>> .r680 |
---|
1783 | |
---|
1784 | os << "de " << j; |
---|
1785 | key = os.str(); |
---|
1786 | os.str(""); |
---|
1787 | os << de[j]; |
---|
1788 | value = os.str(); |
---|
1789 | os.str(""); |
---|
1790 | |
---|
1791 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1792 | |
---|
1793 | os << "delta_ad " << j; |
---|
1794 | key = os.str(); |
---|
1795 | os.str(""); |
---|
1796 | os << delta_ad[j]; |
---|
1797 | value = os.str(); |
---|
1798 | os.str(""); |
---|
1799 | |
---|
1800 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1801 | |
---|
1802 | os << "delta_de " << j; |
---|
1803 | key = os.str(); |
---|
1804 | os.str(""); |
---|
1805 | os << delta_de[j]; |
---|
1806 | value = os.str(); |
---|
1807 | os.str(""); |
---|
1808 | |
---|
1809 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1810 | |
---|
1811 | os << "tsl " << j; |
---|
1812 | key = os.str(); |
---|
1813 | os.str(""); |
---|
1814 | os << tsl[j]; |
---|
1815 | value = os.str(); |
---|
1816 | os.str(""); |
---|
1817 | |
---|
1818 | writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str()); |
---|
1819 | } |
---|
1820 | |
---|
1821 | |
---|
1822 | return true; |
---|
1823 | } |
---|
1824 | |
---|
1825 | |
---|
1826 | bool Alignement::EnregistrementParametresAlignement(int IP, string fileName) |
---|
1827 | { |
---|
1828 | stringstream os; |
---|
1829 | |
---|
1830 | os << IP; |
---|
1831 | |
---|
1832 | return EnregistrementParametresAlignement(os.str(), fileName); |
---|
1833 | } |
---|