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

Last change on this file since 648 was 648, checked in by frichard, 12 years ago

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