Index: /BAORadio/libindi/libindi/communs/alignement.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/alignement.cpp	(revision 681)
+++ /BAORadio/libindi/libindi/communs/alignement.cpp	(revision 682)
@@ -9,4 +9,5 @@
 
 #include "alignement.h"
+#include <QtCore/qvariant.h>
 
 
@@ -21,4 +22,9 @@
 
     InitAlignement();
+
+
+    // initialisation des paramÃštres gÃ©omÃ©triques de l'antenne
+
+    InitParametresInstrument();
 }
 
@@ -45,4 +51,12 @@
     for (int i=0; i< MAXALIGNEMENTANTENNE; i++)
     {
+<<<<<<< .mine
+        ad[i]                           = 0.0;
+        de[i]                           = 0.0;
+        delta_ad[i]                     = 0.0;
+        delta_de[i]                     = 0.0;
+        tsl[i]                          = 0.0;
+        SelectionnePourCalculMatrice[i] = false;
+=======
         ad[i]                           = 0.0;
         de[i]                           = 0.0;
@@ -51,4 +65,5 @@
         tsl[i]                          = 0.0;
 	SelectionnePourCalculMatrice[i] = false;
+>>>>>>> .r680
     }
 
@@ -213,4 +228,7 @@
     AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y);
 
+<<<<<<< .mine
+    Coord a1, a2, a3, m1, m2, m3;
+=======
     AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y);
     AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
@@ -218,8 +236,35 @@
     
     //construit les matrices EQLMN1 & 2
-
+>>>>>>> .r680
+
+<<<<<<< .mine
+    AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y);
+    AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y);
+    AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y);
+=======
     Calculer_Matrice_LMN(m1, m2, m3);
-
+>>>>>>> .r680
+
+<<<<<<< .mine
+    AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y);
+    AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
+    AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y);
+=======
     for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQLMN1[i][j]=GETLMN[i][j];
+>>>>>>> .r680
+
+<<<<<<< .mine
+    //construit les matrices EQLMN1 & 2
+
+    Calculer_Matrice_LMN(m1, m2, m3);
+=======
+    Calculer_Matrice_LMN(a1, a2, a3);
+>>>>>>> .r680
+
+<<<<<<< .mine
+    for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQLMN1[i][j]=GETLMN[i][j];
+=======
+    for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQLMN2[i][j]=GETLMN[i][j];
+>>>>>>> .r680
 
     Calculer_Matrice_LMN(a1, a2, a3);
@@ -332,4 +377,7 @@
     double EQMQ[4][4];
 
+<<<<<<< .mine
+    Coord a1, a2, a3, m1, m2, m3, c1, c2;
+=======
     Coord a1, a2, a3, m1, m2, m3, c1, c2;
     
@@ -366,8 +414,36 @@
     
     //Construit les matrices EQMP et EQMQ
-
+>>>>>>> .r680
+
+<<<<<<< .mine
+    AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y);
+    AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y);
+    AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y);
+=======
     Calculer_Matrice_GETPQ(m1, m2, m3);
-
+>>>>>>> .r680
+
+<<<<<<< .mine
+    AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y);
+    AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
+    AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y);
+=======
     for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQMP[i][j]=GETPQ[i][j];
+>>>>>>> .r680
+
+<<<<<<< .mine
+
+    //Construit les matrices EQMP et EQMQ
+
+    Calculer_Matrice_GETPQ(m1, m2, m3);
+=======
+    Calculer_Matrice_GETPQ(a1, a2, a3);
+>>>>>>> .r680
+
+<<<<<<< .mine
+    for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQMP[i][j]=GETPQ[i][j];
+=======
+    for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQMQ[i][j]=GETPQ[i][j];
+>>>>>>> .r680
 
     Calculer_Matrice_GETPQ(a1, a2, a3);
@@ -403,4 +479,6 @@
     
     
+
+
     // Calcul du vecteur offset sur le ciel
 
@@ -408,4 +486,14 @@
     VECT_OFFSET.y =0.0;//m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2]));
 
+<<<<<<< .mine
+    if (x + y == 0 )
+    {
+        return 0;
+    }
+    else
+    {
+        return  PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y);
+    }
+=======
    if (x + y == 0 )
     {
@@ -416,4 +504,5 @@
         return  PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y);
     }
+>>>>>>> .r680
 }
 
@@ -432,4 +521,71 @@
 
 
+inline int Alignement::ElementsMatriceSimple(Coord aa1, Coord aa2, Coord aa3, Coord mm1, Coord mm2, Coord mm3)
+{
+// On se retouvre Ã  devoir rÃ©soudre les equations:
+
+    // mm1 = aa1 * MATRICE_Correction
+    // mm2 = aa2 * MATRICE_Correction
+    // mm3 = aa3 * MATRICE_Correction
+
+    // et donc Ã  trouver les Ã©lÃ©ments de la matrice MATRICE_Correction en fonction des paramÃštres x, y, z des vecteurs
+    // aa1, aa2, aa3, mm1, mm2, mm3
+
+    // Les Ã©lÃ©ments de la matrice se trouvent aisÃ©ment
+
+    double div= aa1.z*aa2.y*aa3.x - aa1.y*aa2.z*aa3.x - aa1.z*aa2.x*aa3.y +
+                aa1.x*aa2.z*aa3.y + aa1.y*aa2.x*aa3.z - aa1.x*aa2.y*aa3.z;
+
+    if ( div !=0.0 )
+    {
+        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 -
+                         aa1.z*aa2.y*mm3.x + aa1.y*aa2.z*mm3.x)/div);
+
+        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);
+
+        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);
+
+        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 -
+                         aa1.z*aa2.y*mm3.y + aa1.y*aa2.z*mm3.y)/div);
+
+        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 -
+                         aa1.x*aa2.z*mm3.y)/div);
+
+        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 -
+                         aa1.y*aa2.x*mm3.y + aa1.x*aa2.y*mm3.y)/div);
+
+        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 -
+                         aa1.z*aa2.y*mm3.z + aa1.y*aa2.z*mm3.z)/div);
+
+        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 -
+                         aa1.x*aa2.z*mm3.z)/div);
+
+        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 -
+                         aa1.y*aa2.x*mm3.z + aa1.x*aa2.y*mm3.z)/div);
+
+
+
+        MATRICE[1][1] = mm11;
+        MATRICE[2][1] = mm12;
+        MATRICE[3][1] = mm13;
+
+        MATRICE[1][2] = mm21;
+        MATRICE[2][2] = mm22;
+        MATRICE[3][2] = mm23;
+
+        MATRICE[1][3] = mm31;
+        MATRICE[2][3] = mm32;
+        MATRICE[3][3] = mm33;
+
+        //Pour vÃ©rifs
+        //RotationAutourDunAxe(0.3,Pi/2.0-0.1, 0.2);
+
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
+}
 
 /**************************************************************************************
@@ -447,5 +603,5 @@
 ***************************************************************************************/
 
-int Alignement::Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3)
+inline int Alignement::Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3)
 {
     double x, y, z;
@@ -453,6 +609,4 @@
     Coord aa1, aa2, aa3;
     Coord mm1, mm2, mm3;
-
-    stringstream os;
 
     // Pour chaque variable coordonnÃ©es, on calcule d'abord l'azimut et la hauteur de l'objet correspondant
@@ -469,5 +623,4 @@
 
     Azimut(a2.x, a2.y, &aa2.x, &aa2.y);
-    os << "a2.y " << a2.y << "\n";
     x=cos(aa2.x) * cos(aa2.y);
     y=sin(aa2.x) * cos(aa2.y);
@@ -478,5 +631,4 @@
 
     Azimut(a3.x, a3.y, &aa3.x, &aa3.y);
-    os << "a3.y " << a3.y << "\n";
     x=cos(aa3.x) * cos(aa3.y);
     y=sin(aa3.x) * cos(aa3.y);
@@ -487,5 +639,4 @@
 
     Azimut(m1.x, m1.y, &mm1.x, &mm1.y);
-    os << "m1.y " << m1.y << "\n";
     x=cos(mm1.x) * cos(mm1.y);
     y=sin(mm1.x) * cos(mm1.y);
@@ -496,5 +647,4 @@
 
     Azimut(m2.x, m2.y, &mm2.x, &mm2.y);
-    os << "m2.y " << m2.y << "\n";
     x=cos(mm2.x) * cos(mm2.y);
     y=sin(mm2.x) * cos(mm2.y);
@@ -505,5 +655,4 @@
 
     Azimut(m3.x, m3.y, &mm3.x, &mm3.y);
-    os << "m3.y " << m3.y << "\n";
     x=cos(mm3.x) * cos(mm3.y);
     y=sin(mm3.x) * cos(mm3.y);
@@ -513,69 +662,5 @@
     mm3.z=z;
 
-    // On se retouvre Ã  devoir rÃ©soudre les equations:
-
-    // mm1 = aa1 * MATRICE_Correction
-    // mm2 = aa2 * MATRICE_Correction
-    // mm3 = aa3 * MATRICE_Correction
-
-    // et donc Ã  trouver les Ã©lÃ©ments de la matrice MATRICE_Correction en fonction des paramÃštres x, y, z des vecteurs
-    // aa1, aa2, aa3, mm1, mm2, mm3
-
-    // Les Ã©lÃ©ments de la matrice se trouvent aisÃ©ment
-
-    double div= aa1.z*aa2.y*aa3.x - aa1.y*aa2.z*aa3.x - aa1.z*aa2.x*aa3.y +
-                aa1.x*aa2.z*aa3.y + aa1.y*aa2.x*aa3.z - aa1.x*aa2.y*aa3.z;
-
-    if ( div !=0.0 )
-    {
-
-        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 -
-                         aa1.z*aa2.y*mm3.x + aa1.y*aa2.z*mm3.x)/div);
-
-        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);
-
-        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);
-
-        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 -
-                         aa1.z*aa2.y*mm3.y + aa1.y*aa2.z*mm3.y)/div);
-
-        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 -
-                         aa1.x*aa2.z*mm3.y)/div);
-
-        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 -
-                         aa1.y*aa2.x*mm3.y + aa1.x*aa2.y*mm3.y)/div);
-
-        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 -
-                         aa1.z*aa2.y*mm3.z + aa1.y*aa2.z*mm3.z)/div);
-
-        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 -
-                         aa1.x*aa2.z*mm3.z)/div);
-
-        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 -
-                         aa1.y*aa2.x*mm3.z + aa1.x*aa2.y*mm3.z)/div);
-
-
-
-        MATRICE[1][1] = mm11;
-        MATRICE[2][1] = mm12;
-        MATRICE[3][1] = mm13;
-
-        MATRICE[1][2] = mm21;
-        MATRICE[2][2] = mm22;
-        MATRICE[3][2] = mm23;
-
-        MATRICE[1][3] = mm31;
-        MATRICE[2][3] = mm32;
-        MATRICE[3][3] = mm33;
-
-        //Pour vÃ©rifs
-        //RotationAutourDunAxe(0.3,Pi/2.0-0.1, 0.2);
-
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
+    return ElementsMatriceSimple(aa1, aa2, aa3, mm1, mm2, mm3);
 }
 
@@ -591,4 +676,9 @@
 
 
+<<<<<<< .mine
+double Alignement::Determinant()
+{
+    double Det;
+=======
 double Alignement::Determinant()
 {
@@ -598,7 +688,18 @@
     Det = Det - (MATRICE[1][2] * ((MATRICE[2][1] * MATRICE[3][3]) - (MATRICE[3][1] * MATRICE[2][3])));
     Det = Det + (MATRICE[1][3] * ((MATRICE[2][1] * MATRICE[3][2]) - (MATRICE[3][1] * MATRICE[2][2])));
-
+>>>>>>> .r680
+
+<<<<<<< .mine
+    Det = MATRICE[1][1] * ((MATRICE[2][2] * MATRICE[3][3]) - (MATRICE[3][2] * MATRICE[2][ 3]));
+    Det = Det - (MATRICE[1][2] * ((MATRICE[2][1] * MATRICE[3][3]) - (MATRICE[3][1] * MATRICE[2][3])));
+    Det = Det + (MATRICE[1][3] * ((MATRICE[2][1] * MATRICE[3][2]) - (MATRICE[3][1] * MATRICE[2][2])));
+=======
     return Det;
 }
+>>>>>>> .r680
+
+<<<<<<< .mine
+    return Det;
+}
 
 
@@ -613,4 +714,17 @@
 }
 
+=======
+
+
+void Alignement::AzHa2XY(double az, double ha, double *x, double *y)
+{
+    double r = Pidiv2 - ha;
+
+    *x = r * cos(az);
+
+    *y = r * sin(az);
+}
+
+>>>>>>> .r680
 /**************************************************************************************
 ** Calcule la surface d'un triangle de coordonnÃ©es (px1,py1) (px2, py2) (px3, py3)
@@ -624,12 +738,27 @@
     double pxx1, pyy1, pxx2, pyy2, pxx3, pyy3;
 
+<<<<<<< .mine
+    double pxx1, pyy1, pxx2, pyy2, pxx3, pyy3;
+=======
     AzHa2XY(px1, py1, &pxx1, &pyy1);
+>>>>>>> .r680
+
+<<<<<<< .mine
+    AzHa2XY(px1, py1, &pxx1, &pyy1);
 
     AzHa2XY(px2, py2, &pxx2, &pyy2);
-    
+
     AzHa2XY(px3, py3, &pxx3, &pyy3);
-    
+
     ta = (((pxx2 * pyy1) - (pxx1 * pyy2)) ) + (((pxx3 * pyy2) - (pxx2 * pyy3))  ) + (((pxx1 * pyy3) - (pxx3 * pyy1))  );
 
+=======
+    AzHa2XY(px2, py2, &pxx2, &pyy2);
+    
+    AzHa2XY(px3, py3, &pxx3, &pyy3);
+    
+    ta = (((pxx2 * pyy1) - (pxx1 * pyy2)) ) + (((pxx3 * pyy2) - (pxx2 * pyy3))  ) + (((pxx1 * pyy3) - (pxx3 * pyy1))  );
+
+>>>>>>> .r680
     return  fabs(ta) / 2.0;
 }
@@ -659,10 +788,253 @@
     AfficherLog(os.str().c_str(), true);
 
+<<<<<<< .mine
+    /* if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false;
+      if ( DistanceAngulaireEntre2Points(px, py, px2, py2) > 1.2 ) return false;
+      if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false;*/
+=======
   /* if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false;
     if ( DistanceAngulaireEntre2Points(px, py, px2, py2) > 1.2 ) return false;
     if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false;*/
+>>>>>>> .r680
 
     return ( fabs(ta - t1 - t2 - t3) < 1e-10 );
 }
+
+
+void Alignement::InitParametresInstrument()
+{
+    //paramÃštres de l'instrument
+
+    ED          = ED0;
+    CD          = CD0;
+    BC          = BC0;
+    AE          = AE0;
+    I0          = I00;
+    Thau        = Thau0;
+    CoeffMoteur = CoeffMoteur0;
+}
+
+
+double Alignement::Motor2Alt(double pas)
+{
+    return asin(( - pow( ( pas * CoeffMoteur0 ) + I00, 2.0 ) + 128279.4) / 129723.4 ) * N180divPi + Thau0;
+}
+
+double Alignement::Alt2Motor(double targetAlt)
+{
+    /* double I0 = 81.0;
+
+     double I2 = 128279.4 - 129723.4 * sin( (targetAlt - 20.2345) * Pidiv180 );
+
+     double Codalt = (sqrt(I2) - I0) / 0.078947;
+
+     AfficherLog("calcul 1 =%5.0f\n", Codalt);*/
+
+
+
+    double CD2pBC2 = CD * CD + BC * BC;
+
+    double I2 = -2.0 * ED * sqrt( CD2pBC2 ) * sin(  ( targetAlt - Thau ) * Pidiv180 );
+
+    I2 += ED * ED + CD2pBC2 - AE *AE;
+
+    double Codalt = ( sqrt(I2) - I0 ) / CoeffMoteur;
+
+//   AfficherLog("calcul 2=%5.0f\n", Codalt);
+
+    return Codalt;
+}
+
+void Alignement::OptimisationGeometrieAntenne()
+{
+    Coord c1, c2, c3, m1, m2, m3, mm1, mm2, mm3, mm;
+
+    double i, j, k, l, m;
+
+    double memBC = BC0;
+    double memCD = CD0;
+    double memED = ED0;
+    double memAE = AE0;
+    // double memI0 = I00;
+    double memCoeffMoteur = CoeffMoteur0;
+    double memThau = Thau0;
+
+    stringstream os;
+
+    double det;
+
+    double maxdet= 1e50;
+
+    double pas = 0.1;
+
+    double interv = 0.5;
+
+    InitParametresInstrument();
+
+
+
+    c1.x = VerifAngle(ad[0] - tsl[0] + GetTSL());
+    c1.y = de[0];
+
+    Azimut(c1.x, c1.y, &mm.x, &mm.y);
+    c1.x = cos(mm.x) * cos(mm.y);
+    c1.y = sin(mm.x) * cos(mm.y);
+    c1.z = sin(mm.y);
+
+    c2.x = VerifAngle(ad[1] - tsl[1] + GetTSL());
+    c2.y = de[1];
+
+    Azimut(c2.x, c2.y, &mm.x, &mm.y);
+    c2.x = cos(mm.x) * cos(mm.y);
+    c2.y = sin(mm.x) * cos(mm.y);
+    c2.z = sin(mm.y);
+
+    c3.x = VerifAngle(ad[2] - tsl[2] + GetTSL());
+    c3.y = de[2];
+
+    Azimut(c3.x, c3.y, &mm.x, &mm.y);
+    c3.x = cos(mm.x) * cos(mm.y);
+    c3.y = sin(mm.x) * cos(mm.y);
+    c3.z = sin(mm.y);
+
+    m1.x = VerifAngle(delta_ad[0] - tsl[0] + GetTSL());
+    m1.z = 1.0;
+
+    m2.x = VerifAngle(delta_ad[1] - tsl[1] + GetTSL());
+    m2.z = 1.0;
+
+    m3.x = VerifAngle(delta_ad[2] - tsl[2] + GetTSL());
+    m3.z = 1.0;
+
+
+    os << "m1=" << delta_de[0] << "   m11=" <<  Motor2Alt(Alt2Motor(delta_de[0])) << "\n";
+
+    AfficherLog(os.str(), true);
+    os.str("");
+
+    for (i=-interv; i< interv; i += pas)
+    {
+        CoeffMoteur = CoeffMoteur0 + i/100.0;
+
+        for (j=-interv; j<interv; j += pas)
+        {
+            ED = ED0 + j;
+
+            for (k=-interv; k<interv; k += pas)
+            {
+                CD = CD0 + k;
+
+                for (l=-interv; l < interv; l+= pas)
+                {
+                    BC = BC0 + l;
+
+                    Thau = (atan(CD / BC) - atan(18.5 / ED))* N180divPi;
+
+                    for (m=-interv; m< interv; m += pas)
+                    {
+                        AE = AE0 + m;
+
+                        m1.y = Motor2Alt(Alt2Motor(delta_de[0]));
+
+                        Azimut(m1.x, m1.y, &mm.x, &mm.y);
+                        mm1.x = cos(mm.x) * cos(mm.y);
+                        mm1.y = sin(mm.x) * cos(mm.y);
+                        mm1.z = sin(mm.y);
+
+                        m2.y = Motor2Alt(Alt2Motor(delta_de[1]));
+
+                        Azimut(m2.x, m2.y, &mm.x, &mm.y);
+                        mm2.x = cos(mm.x) * cos(mm.y);
+                        mm2.y = sin(mm.x) * cos(mm.y);
+                        mm2.z = sin(mm.y);
+
+                        m3.y = Motor2Alt(Alt2Motor(delta_de[2]));
+
+                        Azimut(m3.x, m3.y, &mm.x, &mm.y);
+                        mm3.x = cos(mm.x) * cos(mm.y);
+                        mm3.y = sin(mm.x) * cos(mm.y);
+                        mm3.z = sin(mm.y);
+
+                        // Calcul de la matrice de correction en fonction de la mÃ©thode d'alignement
+
+                        Matrice_ok = ElementsMatriceSimple(c1, c2, c3 ,mm1, mm2, mm3);
+
+                        det = Determinant();
+
+                        if (fabs(det - 1.0) < maxdet)
+                        {
+                            os << "Determinant=" << det << "\n";
+
+                            os << "CD=" << CD << " ED=" << ED << " BC=" << BC << " AE=" << AE << " Thau=" << Thau << " CoeffMoteur=" << CoeffMoteur << "\n\n";
+
+                            AfficherLog(os.str(), true);
+                            os.str("");
+                            maxdet = fabs(det - 1.0);
+
+                            memCD = CD;
+                            memED = ED;
+                            memAE = AE;
+                            memBC = BC;
+                            memThau = Thau;
+                            memCoeffMoteur = CoeffMoteur;
+                        }
+                    }
+                }
+            }
+        }
+
+        AfficherLog("*\n", true);
+    }
+
+
+    AfficherLog("\n\nFin du calcul.\n", true);
+
+    CD = memCD;
+    ED = memED;
+    AE = memAE;
+    BC = memBC;
+    Thau = memThau;
+    CoeffMoteur = memCoeffMoteur;
+
+    m1.y = Motor2Alt(Alt2Motor(delta_de[0]));
+
+    Azimut(m1.x, m1.y, &mm.x, &mm.y);
+    mm1.x = cos(mm.x) * cos(mm.y);
+    mm1.y = sin(mm.x) * cos(mm.y);
+    mm1.z = sin(mm.y);
+
+    m2.y = Motor2Alt(Alt2Motor(delta_de[1]));
+
+    Azimut(m2.x, m2.y, &mm.x, &mm.y);
+    mm2.x = cos(mm.x) * cos(mm.y);
+    mm2.y = sin(mm.x) * cos(mm.y);
+    mm2.z = sin(mm.y);
+
+    m3.y = Motor2Alt(Alt2Motor(delta_de[2]));
+
+    Azimut(m3.x, m3.y, &mm.x, &mm.y);
+    mm3.x = cos(mm.x) * cos(mm.y);
+    mm3.y = sin(mm.x) * cos(mm.y);
+    mm3.z = sin(mm.y);
+
+    // Calcul de la matrice de correction en fonction de la mÃ©thode d'alignement
+
+    Matrice_ok = ElementsMatriceSimple(c1, c2, c3 ,mm1, mm2, mm3);
+
+    det = Determinant();
+
+
+
+    os << "Determinant=" << det << "\n";
+
+
+    AfficherLog(os.str(), true);
+
+
+
+}
+
+
+
 
 
@@ -712,5 +1084,4 @@
     case TAKI  :
     {
-
         double *distances;
 
@@ -751,6 +1122,11 @@
             os << "Point " << map[i] << "  d=" << distances[i] * N180divPi << "Â°\n";
         }
+<<<<<<< .mine
+
+        for (int i=0; i<nbrcorrections; i++)
+=======
         
         for (int i=0; i<nbrcorrections; i++)
+>>>>>>> .r680
         {
             for (int j=i+1; j<nbrcorrections; j++)
@@ -824,5 +1200,9 @@
         os << "\nUtilisation du triangle : " << map[best1] << " " << map[best2] << " " << map[best3]  << "\n" ;
 
+<<<<<<< .mine
+        // if (MethodeAlignement == SIMPLE)
+=======
        // if (MethodeAlignement == SIMPLE)
+>>>>>>> .r680
         {
             c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL());
@@ -838,4 +1218,11 @@
             c3.z = 1.0;
         }
+<<<<<<< .mine
+        /*    else
+            {
+                c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL());
+                c1.y = de[map[best1]];
+                c1.z = 1.0;
+=======
     /*    else
         {
@@ -843,9 +1230,25 @@
             c1.y = de[map[best1]];
             c1.z = 1.0;
-
+>>>>>>> .r680
+
+<<<<<<< .mine
+                c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL());
+                c2.y = de[map[best2]];
+                c2.z = 1.0;
+=======
             c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL());
             c2.y = de[map[best2]];
             c2.z = 1.0;
-
+>>>>>>> .r680
+
+<<<<<<< .mine
+                c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL());
+                c3.y = de[map[best3]];
+                c3.z = 1.0;
+            }*/
+
+        m1.x = VerifAngle(delta_ad[map[best1]] - tsl[map[best1]] + GetTSL());
+        m1.y = delta_de[map[best1]];
+=======
             c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL());
             c3.y = de[map[best3]];
@@ -855,4 +1258,5 @@
         m1.x = VerifAngle(delta_ad[map[best1]] - tsl[map[best1]] + GetTSL());
         m1.y = delta_de[map[best1]];
+>>>>>>> .r680
         m1.z = 1.0;
 
@@ -894,4 +1298,7 @@
 
 
+<<<<<<< .mine
+    for (int i=0; i<nbrcorrections; i++) SelectionnePourCalculMatrice[i] = false;
+=======
     for (int i=0; i<nbrcorrections; i++) SelectionnePourCalculMatrice[i] = false;
     
@@ -900,5 +1307,13 @@
     SelectionnePourCalculMatrice[map[best3]] = true;
     
-
+>>>>>>> .r680
+
+<<<<<<< .mine
+    SelectionnePourCalculMatrice[map[best1]] = true;
+    SelectionnePourCalculMatrice[map[best2]] = true;
+    SelectionnePourCalculMatrice[map[best3]] = true;
+
+
+=======
     //VÃ©rifications supp
     /*
@@ -949,4 +1364,5 @@
 
 
+>>>>>>> .r680
     //Afficher les messages de cette fonction
 
@@ -966,5 +1382,9 @@
 
     // sauvegarder la position courante
+<<<<<<< .mine
+    // long pos = fichier.tellg();
+=======
    // long pos = fichier.tellg();
+>>>>>>> .r680
     // se placer en fin de fichier
     fichier.seekg( 0 , std::ios_base::end );
@@ -1018,7 +1438,13 @@
 
 
+<<<<<<< .mine
     nbrcorrections = 0;
-    
+
     for (int j=0; j < MAXALIGNEMENTANTENNE; j++)
+=======
+    nbrcorrections = 0;
+    
+    for (int j=0; j < MAXALIGNEMENTANTENNE; j++)
+>>>>>>> .r680
     {
         os2 << "ad " << j;
@@ -1059,7 +1485,15 @@
             // -> on les applique...
 
+<<<<<<< .mine
+=======
             
+>>>>>>> .r680
+
+<<<<<<< .mine
 
             if (delta_ad[nbrcorrections] != atof(delta_ad_data) || delta_de[nbrcorrections] != atof(delta_de_data))
+=======
+            if (delta_ad[nbrcorrections] != atof(delta_ad_data) || delta_de[nbrcorrections] != atof(delta_de_data))
+>>>>>>> .r680
             {
                 ad[nbrcorrections] = atof(ad_data);
@@ -1073,13 +1507,24 @@
                 tsl[nbrcorrections] = atof(tsl_data);
 
+<<<<<<< .mine
+                os2 << "Correction antenne ip=" << IP <<  " ad=" << ad[nbrcorrections] << " de=" << de[nbrcorrections] << " deltaAD=" <<
+                    delta_ad[nbrcorrections] << " deltaDe=" << delta_de[nbrcorrections] << " tsl=" << tsl[nbrcorrections] << "\n";
+=======
                 os2 << "Correction antenne ip=" << IP <<  " ad=" << ad[nbrcorrections] << " de=" << de[nbrcorrections] << " deltaAD=" << 
                 delta_ad[nbrcorrections] << " deltaDe=" << delta_de[nbrcorrections] << " tsl=" << tsl[nbrcorrections] << "\n";
+>>>>>>> .r680
 
                 AfficherLog(&os2, true);
 
                 modificationAlignement = true;
+<<<<<<< .mine
+
+                nbrcorrections++;
+            }
+=======
 		
 		nbrcorrections++;
             }           
+>>>>>>> .r680
         }
 
@@ -1315,4 +1760,16 @@
     }
 
+<<<<<<< .mine
+    for (int j = 0; j < nbrcorrections; j++) if (ad[j]!=0.0 && de[j]!=0.0)
+        {
+            os << "ad " << j;
+            key     = os.str();
+            os.str("");
+            os << ad[j];
+            value = os.str();
+            os.str("");
+
+            writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+=======
     for (int j = 0; j < nbrcorrections; j++) if (ad[j]!=0.0 && de[j]!=0.0)
     {
@@ -1323,43 +1780,42 @@
         value = os.str();
         os.str("");
-
-        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
-
-        os << "de " << j;
-        key     = os.str();
-        os.str("");
-        os << de[j];
-        value = os.str();
-        os.str("");
-
-        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
-
-        os << "delta_ad " << j;
-        key     = os.str();
-        os.str("");
-        os << delta_ad[j];
-        value = os.str();
-        os.str("");
-
-        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
-
-        os << "delta_de " << j;
-        key     = os.str();
-        os.str("");
-        os << delta_de[j];
-        value = os.str();
-        os.str("");
-
-        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
-
-        os << "tsl " << j;
-        key     = os.str();
-        os.str("");
-        os << tsl[j];
-        value = os.str();
-        os.str("");
-
-        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
-    }
+>>>>>>> .r680
+
+            os << "de " << j;
+            key     = os.str();
+            os.str("");
+            os << de[j];
+            value = os.str();
+            os.str("");
+
+            writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+            os << "delta_ad " << j;
+            key     = os.str();
+            os.str("");
+            os << delta_ad[j];
+            value = os.str();
+            os.str("");
+
+            writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+            os << "delta_de " << j;
+            key     = os.str();
+            os.str("");
+            os << delta_de[j];
+            value = os.str();
+            os.str("");
+
+            writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+            os << "tsl " << j;
+            key     = os.str();
+            os.str("");
+            os << tsl[j];
+            value = os.str();
+            os.str("");
+
+            writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+        }
 
 
Index: /BAORadio/libindi/libindi/communs/alignement.h
===================================================================
--- /BAORadio/libindi/libindi/communs/alignement.h	(revision 681)
+++ /BAORadio/libindi/libindi/communs/alignement.h	(revision 682)
@@ -70,7 +70,8 @@
     void Identity();
     void RotationAutourDunAxe(double t, double r, double alpha);
-    
+
     // MÃ©thode de correction "simple
-    int  Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3);
+    inline int Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3);
+    inline int ElementsMatriceSimple(Coord aa1, Coord aa2, Coord aa3, Coord mm1, Coord mm2, Coord mm3);
     void AppliquerMatriceCorrectionSimple( Coord * result, Coord vect);
 
@@ -91,10 +92,19 @@
 
     double Surface_Triangle(double px1, double py1, double px2, double py2, double px3, double py3);
+<<<<<<< .mine
+    void   AzHa2XY(double az, double ha, double *x, double *y);
+    bool   PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3);
+=======
     void AzHa2XY(double az, double ha, double *x, double *y);
     bool PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3);
+>>>>>>> .r680
     
     double Determinant();
 
-
+    inline double Determinant();
+    void   InitParametresInstrument();
+    void   OptimisationGeometrieAntenne();
+    double Alt2Motor(double targetAlt);
+    inline double Motor2Alt(double pas);
 
 
@@ -116,4 +126,9 @@
     bool SelectionnePourCalculMatrice[MAXALIGNEMENTANTENNE];
 
+    long int deltaAZ;                           // delta en azimut et en hauteur pour une correction Ã  la raquette
+    long int deltaHA;                           // hors procÃ©dure d'alignement
+
+    bool SelectionnePourCalculMatrice[MAXALIGNEMENTANTENNE];
+
     double ad[MAXALIGNEMENTANTENNE];            // CoordonnÃ©es horaires d'un point de correction
 
@@ -133,4 +148,15 @@
     // dans les modes d'alignement AFFINE/TAKI
     double GETPQ[4][4];
+
+
+    double BC;                          //ParamÃštres de l'instrument
+    // Formule de Marc
+    double CD;
+    double ED;
+    double AE;
+    double I0;
+    double CoeffMoteur;
+    double Thau;
+
 };
 
Index: /BAORadio/libindi/libindi/communs/astro.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/astro.cpp	(revision 681)
+++ /BAORadio/libindi/libindi/communs/astro.cpp	(revision 682)
@@ -567,13 +567,21 @@
 ***************************************************************************************/
 
-void Astro::Azimut(double Ar, double De, double *azi, double *hau)
+ void Astro::Azimut(double Ar, double De, double *azi, double *hau)
 {
     double ah = tsl - Ar;
-
-    double zc = sin(Latitude) * sin(De) + cos(Latitude) * cos(De) * cos(ah);
+    
+    double cosLatitude = cos(Latitude);
+    double sinLatitude = sin(Latitude);
+    double cosDe_cosAh = cos(De) * cos(ah);
+    double sinDe       = sin(De);
+   
+    
+    double zc = sinLatitude * sinDe + cosLatitude * cosDe_cosAh;
     double ht = atan(zc / sqrt((-zc * zc) + 1.0));
-
-    double a1 = cos(De) * sin(ah) / cos(ht);
-    double ac = (-cos(Latitude) * sin(De) + sin(Latitude) * cos(De) * cos(ah)) / cos(ht);
+    
+    double cosHt       = cos(ht);
+
+    double a1 = cos(De) * sin(ah) / cosHt;
+    double ac = (-cosLatitude * sinDe + sinLatitude * cosDe_cosAh) / cosHt;
     double az = atan(a1 / sqrt((-a1*a1)+1.0));
 
Index: /BAORadio/libindi/libindi/communs/astro.h
===================================================================
--- /BAORadio/libindi/libindi/communs/astro.h	(revision 681)
+++ /BAORadio/libindi/libindi/communs/astro.h	(revision 682)
@@ -52,5 +52,7 @@
     double Arrondi(double a);
     string DHMS(double mema, bool HMS);
-    void   Azimut(double Ar, double De, double *azi, double *hau);
+     void   Azimut(double Ar, double De, double *azi, double *hau);
+    void   AzHa2ADDe(double Az, double Ha, double *AD, double *Dec);
+    void   RechercheAzimutFinSuivi(double AD, double Dec, long int *azmin, long int *azmax);
     void   AzHa2ADDe(double Az, double Ha, double *AD, double *Dec);
     void   RechercheAzimutFinSuivi(double AD, double Dec, long int *azmin, long int *azmax);
Index: /BAORadio/libindi/libindi/communs/const.h
===================================================================
--- /BAORadio/libindi/libindi/communs/const.h	(revision 681)
+++ /BAORadio/libindi/libindi/communs/const.h	(revision 682)
@@ -8,4 +8,14 @@
 //////////////////////////////////////////
 
+
+// ParamÃštres de l'instrument
+
+#define ED0 243.2
+#define CD0 111.01
+#define BC0 242.5
+#define AE0 44.68
+#define I00 81.0
+#define CoeffMoteur0 0.078947
+#define Thau0 20.2345
 
 // dimensions des tableaux
Index: /BAORadio/libindi/libindi/drivers/telescope/BAO.cpp
===================================================================
--- /BAORadio/libindi/libindi/drivers/telescope/BAO.cpp	(revision 681)
+++ /BAORadio/libindi/libindi/drivers/telescope/BAO.cpp	(revision 682)
@@ -11,5 +11,4 @@
 
 #include "BAO.h"
-#include "../communs/alt2motor.h"
 
 
@@ -496,4 +495,7 @@
 
 
+
+
+
 /**************************************************************************************
 ** En cas de changement de texte dans la boÃ®te de dialogue (par exemple : changement du
@@ -634,4 +636,29 @@
                     return;
                 }
+            }
+            else if (chaine[0] == 'M')
+            {
+                if  (Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections >=3 )
+                {
+                    Sockets[targetAlignmentIP].AlignementAntenne->AlignementEnCours = 0;
+                    Sockets[targetAlignmentIP].AlignementAntenne->CalculerMatriceCorrection(targetRA, targetDEC);
+                }
+                else
+                {
+                    Sockets[targetAlignmentIP].AlignementAntenne->Identity();
+
+                    Sockets[targetAlignmentIP].AlignementAntenne->Matrice_ok = false;
+                }
+
+                IDSetText(&CommandTP, "Calcul des matrices de correction\n" );
+            }
+            else if (chaine[0] == 'O')
+            {
+                IDSetText(&CommandTP, "Optimisation de la geometrie de l antenne\n" );
+		
+		if (targetAlignmentIP != -1)
+		{
+		  Sockets[targetAlignmentIP].AlignementAntenne->OptimisationGeometrieAntenne();
+		}                
             }
             else if (chaine[0] == 'C')
@@ -981,14 +1008,14 @@
                     targetDEC * Pidiv180;
             }
-            
+
             for (int i=0; i<SocketsNumber; i++) if (Sockets[i].Connected)
-	    {
-	      if ( Sockets[i].AlignementAntenne->AlignementEnCours == 0 )
-	      {
-		Sockets[i].AlignementAntenne->CalculerMatriceCorrection(targetRA, targetDEC);
-	      }
-	    }
-		
-	      
+                {
+                    if ( Sockets[i].AlignementAntenne->AlignementEnCours == 0 )
+                    {
+                        Sockets[i].AlignementAntenne->CalculerMatriceCorrection(targetRA, targetDEC);
+                    }
+                }
+
+
 
             // on les affiche dans les logs
@@ -1818,7 +1845,7 @@
 
                     vect.z = 1.0;
-      
-
-             
+
+
+
                     Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionAffine(&result, vect);
 
@@ -1897,5 +1924,5 @@
                 // On applique la formule de Marc pour convertir la hauteur en nombre de pas codeur alt
 
-                Sockets[i].TargetPosition.y = (long int) Arrondi( Alt2Motor( targetAlt ) );
+                Sockets[i].TargetPosition.y = (long int) Arrondi( Sockets[i].AlignementAntenne->Alt2Motor( targetAlt ) );
 
                 //4000 pas pour 360Â° sur l'axe az
Index: /BAORadio/libindi/libindi/drivers/telescope/BAO.h
===================================================================
--- /BAORadio/libindi/libindi/drivers/telescope/BAO.h	(revision 681)
+++ /BAORadio/libindi/libindi/drivers/telescope/BAO.h	(revision 682)
@@ -136,5 +136,6 @@
     int  get_switch_index(ISwitchVectorProperty *sp);
     void ADDEC2Motor(double newRA, double newDEC);
-
+    
+  
     /*******************************************************/
     /* Simulation Routines
@@ -257,5 +258,5 @@
     long int delta_ha;
     
-    
+   
 };
 
