source: BAORadio/libindi/libindi/communs/alignement.cpp @ 682

Last change on this file since 682 was 682, checked in by frichard, 12 years ago
File size: 51.6 KB
Line 
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
19Alignement::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
37Alignement::~Alignement()
38{
39}
40
41
42/**************************************************************************************
43** Initialisations des vecteurs et des paramÚtres d'alignement
44**
45***************************************************************************************/
46
47void 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
110void 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
124void 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
150void 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
181void 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
217int 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
336void 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
357void 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
372int 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
516void 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
523inline 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
605inline 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
668void 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
679double Alignement::Determinant()
680{
681    double Det;
682=======
683double 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
707void 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
719void 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
734double 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
773bool 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
804void 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
818double Alignement::Motor2Alt(double pas)
819{
820    return asin(( - pow( ( pas * CoeffMoteur0 ) + I00, 2.0 ) + 128279.4) / 129723.4 ) * N180divPi + Thau0;
821}
822
823double 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
848void 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
1051void 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
1378bool 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
1401bool 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
1659bool 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
1826bool Alignement::EnregistrementParametresAlignement(int IP, string fileName)
1827{
1828    stringstream os;
1829
1830    os << IP;
1831
1832    return EnregistrementParametresAlignement(os.str(), fileName);
1833}
Note: See TracBrowser for help on using the repository browser.