Changeset 682


Ignore:
Timestamp:
May 24, 2012, 5:19:03 PM (12 years ago)
Author:
frichard
Message:
 
Location:
BAORadio/libindi/libindi
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • BAORadio/libindi/libindi/communs/alignement.cpp

    r677 r682  
    99
    1010#include "alignement.h"
     11#include <QtCore/qvariant.h>
    1112
    1213
    … …  
    2122
    2223    InitAlignement();
     24
     25
     26    // initialisation des paramÚtres géométriques de l'antenne
     27
     28    InitParametresInstrument();
    2329}
    2430
    … …  
    4551    for (int i=0; i< MAXALIGNEMENTANTENNE; i++)
    4652    {
     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=======
    4761        ad[i]                           = 0.0;
    4862        de[i]                           = 0.0;
    … …  
    5165        tsl[i]                          = 0.0;
    5266        SelectionnePourCalculMatrice[i] = false;
     67>>>>>>> .r680
    5368    }
    5469
    … …  
    213228    AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y);
    214229
     230<<<<<<< .mine
     231    Coord a1, a2, a3, m1, m2, m3;
     232=======
    215233    AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y);
    216234    AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
    … …  
    218236   
    219237    //construit les matrices EQLMN1 & 2
    220 
     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=======
    221245    Calculer_Matrice_LMN(m1, m2, m3);
    222 
     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=======
    223253    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
    224269
    225270    Calculer_Matrice_LMN(a1, a2, a3);
    … …  
    332377    double EQMQ[4][4];
    333378
     379<<<<<<< .mine
     380    Coord a1, a2, a3, m1, m2, m3, c1, c2;
     381=======
    334382    Coord a1, a2, a3, m1, m2, m3, c1, c2;
    335383   
    … …  
    366414   
    367415    //Construit les matrices EQMP et EQMQ
    368 
     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=======
    369423    Calculer_Matrice_GETPQ(m1, m2, m3);
    370 
     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=======
    371431    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
    372448
    373449    Calculer_Matrice_GETPQ(a1, a2, a3);
    … …  
    403479   
    404480   
     481
     482
    405483    // Calcul du vecteur offset sur le ciel
    406484
    … …  
    408486    VECT_OFFSET.y =0.0;//m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2]));
    409487
     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=======
    410498   if (x + y == 0 )
    411499    {
    … …  
    416504        return  PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y);
    417505    }
     506>>>>>>> .r680
    418507}
    419508
    … …  
    432521
    433522
     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}
    434590
    435591/**************************************************************************************
    … …  
    447603***************************************************************************************/
    448604
    449 int Alignement::Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3)
     605inline int Alignement::Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3)
    450606{
    451607    double x, y, z;
    … …  
    453609    Coord aa1, aa2, aa3;
    454610    Coord mm1, mm2, mm3;
    455 
    456     stringstream os;
    457611
    458612    // Pour chaque variable coordonnées, on calcule d'abord l'azimut et la hauteur de l'objet correspondant
    … …  
    469623
    470624    Azimut(a2.x, a2.y, &aa2.x, &aa2.y);
    471     os << "a2.y " << a2.y << "\n";
    472625    x=cos(aa2.x) * cos(aa2.y);
    473626    y=sin(aa2.x) * cos(aa2.y);
    … …  
    478631
    479632    Azimut(a3.x, a3.y, &aa3.x, &aa3.y);
    480     os << "a3.y " << a3.y << "\n";
    481633    x=cos(aa3.x) * cos(aa3.y);
    482634    y=sin(aa3.x) * cos(aa3.y);
    … …  
    487639
    488640    Azimut(m1.x, m1.y, &mm1.x, &mm1.y);
    489     os << "m1.y " << m1.y << "\n";
    490641    x=cos(mm1.x) * cos(mm1.y);
    491642    y=sin(mm1.x) * cos(mm1.y);
    … …  
    496647
    497648    Azimut(m2.x, m2.y, &mm2.x, &mm2.y);
    498     os << "m2.y " << m2.y << "\n";
    499649    x=cos(mm2.x) * cos(mm2.y);
    500650    y=sin(mm2.x) * cos(mm2.y);
    … …  
    505655
    506656    Azimut(m3.x, m3.y, &mm3.x, &mm3.y);
    507     os << "m3.y " << m3.y << "\n";
    508657    x=cos(mm3.x) * cos(mm3.y);
    509658    y=sin(mm3.x) * cos(mm3.y);
    … …  
    513662    mm3.z=z;
    514663
    515     // On se retouvre à devoir résoudre les equations:
    516 
    517     // mm1 = aa1 * MATRICE_Correction
    518     // mm2 = aa2 * MATRICE_Correction
    519     // mm3 = aa3 * MATRICE_Correction
    520 
    521     // et donc à trouver les éléments de la matrice MATRICE_Correction en fonction des paramÚtres x, y, z des vecteurs
    522     // aa1, aa2, aa3, mm1, mm2, mm3
    523 
    524     // Les éléments de la matrice se trouvent aisément
    525 
    526     double div= aa1.z*aa2.y*aa3.x - aa1.y*aa2.z*aa3.x - aa1.z*aa2.x*aa3.y +
    527                 aa1.x*aa2.z*aa3.y + aa1.y*aa2.x*aa3.z - aa1.x*aa2.y*aa3.z;
    528 
    529     if ( div !=0.0 )
    530     {
    531 
    532         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 -
    533                          aa1.z*aa2.y*mm3.x + aa1.y*aa2.z*mm3.x)/div);
    534 
    535         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);
    536 
    537         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);
    538 
    539         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 -
    540                          aa1.z*aa2.y*mm3.y + aa1.y*aa2.z*mm3.y)/div);
    541 
    542         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 -
    543                          aa1.x*aa2.z*mm3.y)/div);
    544 
    545         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 -
    546                          aa1.y*aa2.x*mm3.y + aa1.x*aa2.y*mm3.y)/div);
    547 
    548         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 -
    549                          aa1.z*aa2.y*mm3.z + aa1.y*aa2.z*mm3.z)/div);
    550 
    551         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 -
    552                          aa1.x*aa2.z*mm3.z)/div);
    553 
    554         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 -
    555                          aa1.y*aa2.x*mm3.z + aa1.x*aa2.y*mm3.z)/div);
    556 
    557 
    558 
    559         MATRICE[1][1] = mm11;
    560         MATRICE[2][1] = mm12;
    561         MATRICE[3][1] = mm13;
    562 
    563         MATRICE[1][2] = mm21;
    564         MATRICE[2][2] = mm22;
    565         MATRICE[3][2] = mm23;
    566 
    567         MATRICE[1][3] = mm31;
    568         MATRICE[2][3] = mm32;
    569         MATRICE[3][3] = mm33;
    570 
    571         //Pour vérifs
    572         //RotationAutourDunAxe(0.3,Pi/2.0-0.1, 0.2);
    573 
    574         return 1;
    575     }
    576     else
    577     {
    578         return 0;
    579     }
     664    return ElementsMatriceSimple(aa1, aa2, aa3, mm1, mm2, mm3);
    580665}
    581666
    … …  
    591676
    592677
     678<<<<<<< .mine
     679double Alignement::Determinant()
     680{
     681    double Det;
     682=======
    593683double Alignement::Determinant()
    594684{
    … …  
    598688    Det = Det - (MATRICE[1][2] * ((MATRICE[2][1] * MATRICE[3][3]) - (MATRICE[3][1] * MATRICE[2][3])));
    599689    Det = Det + (MATRICE[1][3] * ((MATRICE[2][1] * MATRICE[3][2]) - (MATRICE[3][1] * MATRICE[2][2])));
    600 
     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=======
    601697    return Det;
    602698}
     699>>>>>>> .r680
     700
     701<<<<<<< .mine
     702    return Det;
     703}
    603704
    604705
    … …  
    613714}
    614715
     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
    615729/**************************************************************************************
    616730** Calcule la surface d'un triangle de coordonnées (px1,py1) (px2, py2) (px3, py3)
    … …  
    624738    double pxx1, pyy1, pxx2, pyy2, pxx3, pyy3;
    625739
     740<<<<<<< .mine
     741    double pxx1, pyy1, pxx2, pyy2, pxx3, pyy3;
     742=======
    626743    AzHa2XY(px1, py1, &pxx1, &pyy1);
     744>>>>>>> .r680
     745
     746<<<<<<< .mine
     747    AzHa2XY(px1, py1, &pxx1, &pyy1);
    627748
    628749    AzHa2XY(px2, py2, &pxx2, &pyy2);
    629    
     750
    630751    AzHa2XY(px3, py3, &pxx3, &pyy3);
    631    
     752
    632753    ta = (((pxx2 * pyy1) - (pxx1 * pyy2)) ) + (((pxx3 * pyy2) - (pxx2 * pyy3))  ) + (((pxx1 * pyy3) - (pxx3 * pyy1))  );
    633754
     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
    634763    return  fabs(ta) / 2.0;
    635764}
    … …  
    659788    AfficherLog(os.str().c_str(), true);
    660789
     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=======
    661795  /* if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false;
    662796    if ( DistanceAngulaireEntre2Points(px, py, px2, py2) > 1.2 ) return false;
    663797    if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false;*/
     798>>>>>>> .r680
    664799
    665800    return ( fabs(ta - t1 - t2 - t3) < 1e-10 );
    666801}
     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
    6671039
    6681040
    … …  
    7121084    case TAKI  :
    7131085    {
    714 
    7151086        double *distances;
    7161087
    … …  
    7511122            os << "Point " << map[i] << "  d=" << distances[i] * N180divPi << "°\n";
    7521123        }
     1124<<<<<<< .mine
     1125
     1126        for (int i=0; i<nbrcorrections; i++)
     1127=======
    7531128       
    7541129        for (int i=0; i<nbrcorrections; i++)
     1130>>>>>>> .r680
    7551131        {
    7561132            for (int j=i+1; j<nbrcorrections; j++)
    … …  
    8241200        os << "\nUtilisation du triangle : " << map[best1] << " " << map[best2] << " " << map[best3]  << "\n" ;
    8251201
     1202<<<<<<< .mine
     1203        // if (MethodeAlignement == SIMPLE)
     1204=======
    8261205       // if (MethodeAlignement == SIMPLE)
     1206>>>>>>> .r680
    8271207        {
    8281208            c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL());
    … …  
    8381218            c3.z = 1.0;
    8391219        }
     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=======
    8401227    /*    else
    8411228        {
    … …  
    8431230            c1.y = de[map[best1]];
    8441231            c1.z = 1.0;
    845 
     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=======
    8461239            c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL());
    8471240            c2.y = de[map[best2]];
    8481241            c2.z = 1.0;
    849 
     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=======
    8501253            c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL());
    8511254            c3.y = de[map[best3]];
    … …  
    8551258        m1.x = VerifAngle(delta_ad[map[best1]] - tsl[map[best1]] + GetTSL());
    8561259        m1.y = delta_de[map[best1]];
     1260>>>>>>> .r680
    8571261        m1.z = 1.0;
    8581262
    … …  
    8941298
    8951299
     1300<<<<<<< .mine
     1301    for (int i=0; i<nbrcorrections; i++) SelectionnePourCalculMatrice[i] = false;
     1302=======
    8961303    for (int i=0; i<nbrcorrections; i++) SelectionnePourCalculMatrice[i] = false;
    8971304   
    … …  
    9001307    SelectionnePourCalculMatrice[map[best3]] = true;
    9011308   
    902 
     1309>>>>>>> .r680
     1310
     1311<<<<<<< .mine
     1312    SelectionnePourCalculMatrice[map[best1]] = true;
     1313    SelectionnePourCalculMatrice[map[best2]] = true;
     1314    SelectionnePourCalculMatrice[map[best3]] = true;
     1315
     1316
     1317=======
    9031318    //Vérifications supp
    9041319    /*
    … …  
    9491364
    9501365
     1366>>>>>>> .r680
    9511367    //Afficher les messages de cette fonction
    9521368
    … …  
    9661382
    9671383    // sauvegarder la position courante
     1384<<<<<<< .mine
     1385    // long pos = fichier.tellg();
     1386=======
    9681387   // long pos = fichier.tellg();
     1388>>>>>>> .r680
    9691389    // se placer en fin de fichier
    9701390    fichier.seekg( 0 , std::ios_base::end );
    … …  
    10181438
    10191439
     1440<<<<<<< .mine
    10201441    nbrcorrections = 0;
    1021    
     1442
    10221443    for (int j=0; j < MAXALIGNEMENTANTENNE; j++)
     1444=======
     1445    nbrcorrections = 0;
     1446   
     1447    for (int j=0; j < MAXALIGNEMENTANTENNE; j++)
     1448>>>>>>> .r680
    10231449    {
    10241450        os2 << "ad " << j;
    … …  
    10591485            // -> on les applique...
    10601486
     1487<<<<<<< .mine
     1488=======
    10611489           
     1490>>>>>>> .r680
     1491
     1492<<<<<<< .mine
    10621493
    10631494            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
    10641498            {
    10651499                ad[nbrcorrections] = atof(ad_data);
    … …  
    10731507                tsl[nbrcorrections] = atof(tsl_data);
    10741508
     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=======
    10751513                os2 << "Correction antenne ip=" << IP <<  " ad=" << ad[nbrcorrections] << " de=" << de[nbrcorrections] << " deltaAD=" <<
    10761514                delta_ad[nbrcorrections] << " deltaDe=" << delta_de[nbrcorrections] << " tsl=" << tsl[nbrcorrections] << "\n";
     1515>>>>>>> .r680
    10771516
    10781517                AfficherLog(&os2, true);
    10791518
    10801519                modificationAlignement = true;
     1520<<<<<<< .mine
     1521
     1522                nbrcorrections++;
     1523            }
     1524=======
    10811525               
    10821526                nbrcorrections++;
    10831527            }           
     1528>>>>>>> .r680
    10841529        }
    10851530
    … …  
    13151760    }
    13161761
     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=======
    13171774    for (int j = 0; j < nbrcorrections; j++) if (ad[j]!=0.0 && de[j]!=0.0)
    13181775    {
    … …  
    13231780        value = os.str();
    13241781        os.str("");
    1325 
    1326         writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
    1327 
    1328         os << "de " << j;
    1329         key     = os.str();
    1330         os.str("");
    1331         os << de[j];
    1332         value = os.str();
    1333         os.str("");
    1334 
    1335         writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
    1336 
    1337         os << "delta_ad " << j;
    1338         key     = os.str();
    1339         os.str("");
    1340         os << delta_ad[j];
    1341         value = os.str();
    1342         os.str("");
    1343 
    1344         writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
    1345 
    1346         os << "delta_de " << j;
    1347         key     = os.str();
    1348         os.str("");
    1349         os << delta_de[j];
    1350         value = os.str();
    1351         os.str("");
    1352 
    1353         writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
    1354 
    1355         os << "tsl " << j;
    1356         key     = os.str();
    1357         os.str("");
    1358         os << tsl[j];
    1359         value = os.str();
    1360         os.str("");
    1361 
    1362         writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
    1363     }
     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        }
    13641820
    13651821

  • BAORadio/libindi/libindi/communs/alignement.h

    r677 r682  
    7070    void Identity();
    7171    void RotationAutourDunAxe(double t, double r, double alpha);
    72    
     72
    7373    // Méthode de correction "simple
    74     int  Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3);
     74    inline int Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3);
     75    inline int ElementsMatriceSimple(Coord aa1, Coord aa2, Coord aa3, Coord mm1, Coord mm2, Coord mm3);
    7576    void AppliquerMatriceCorrectionSimple( Coord * result, Coord vect);
    7677
    … …  
    9192
    9293    double Surface_Triangle(double px1, double py1, double px2, double py2, double px3, double py3);
     94<<<<<<< .mine
     95    void   AzHa2XY(double az, double ha, double *x, double *y);
     96    bool   PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3);
     97=======
    9398    void AzHa2XY(double az, double ha, double *x, double *y);
    9499    bool PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3);
     100>>>>>>> .r680
    95101   
    96102    double Determinant();
    97103
    98 
     104    inline double Determinant();
     105    void   InitParametresInstrument();
     106    void   OptimisationGeometrieAntenne();
     107    double Alt2Motor(double targetAlt);
     108    inline double Motor2Alt(double pas);
    99109
    100110
    … …  
    116126    bool SelectionnePourCalculMatrice[MAXALIGNEMENTANTENNE];
    117127
     128    long int deltaAZ;                           // delta en azimut et en hauteur pour une correction à la raquette
     129    long int deltaHA;                           // hors procédure d'alignement
     130
     131    bool SelectionnePourCalculMatrice[MAXALIGNEMENTANTENNE];
     132
    118133    double ad[MAXALIGNEMENTANTENNE];            // Coordonnées horaires d'un point de correction
    119134
    … …  
    133148    // dans les modes d'alignement AFFINE/TAKI
    134149    double GETPQ[4][4];
     150
     151
     152    double BC;                          //ParamÚtres de l'instrument
     153    // Formule de Marc
     154    double CD;
     155    double ED;
     156    double AE;
     157    double I0;
     158    double CoeffMoteur;
     159    double Thau;
     160
    135161};
    136162

  • BAORadio/libindi/libindi/communs/astro.cpp

    r677 r682  
    567567***************************************************************************************/
    568568
    569 void Astro::Azimut(double Ar, double De, double *azi, double *hau)
     569 void Astro::Azimut(double Ar, double De, double *azi, double *hau)
    570570{
    571571    double ah = tsl - Ar;
    572 
    573     double zc = sin(Latitude) * sin(De) + cos(Latitude) * cos(De) * cos(ah);
     572   
     573    double cosLatitude = cos(Latitude);
     574    double sinLatitude = sin(Latitude);
     575    double cosDe_cosAh = cos(De) * cos(ah);
     576    double sinDe       = sin(De);
     577   
     578   
     579    double zc = sinLatitude * sinDe + cosLatitude * cosDe_cosAh;
    574580    double ht = atan(zc / sqrt((-zc * zc) + 1.0));
    575 
    576     double a1 = cos(De) * sin(ah) / cos(ht);
    577     double ac = (-cos(Latitude) * sin(De) + sin(Latitude) * cos(De) * cos(ah)) / cos(ht);
     581   
     582    double cosHt       = cos(ht);
     583
     584    double a1 = cos(De) * sin(ah) / cosHt;
     585    double ac = (-cosLatitude * sinDe + sinLatitude * cosDe_cosAh) / cosHt;
    578586    double az = atan(a1 / sqrt((-a1*a1)+1.0));
    579587

  • BAORadio/libindi/libindi/communs/astro.h

    r677 r682  
    5252    double Arrondi(double a);
    5353    string DHMS(double mema, bool HMS);
    54     void   Azimut(double Ar, double De, double *azi, double *hau);
     54     void   Azimut(double Ar, double De, double *azi, double *hau);
     55    void   AzHa2ADDe(double Az, double Ha, double *AD, double *Dec);
     56    void   RechercheAzimutFinSuivi(double AD, double Dec, long int *azmin, long int *azmax);
    5557    void   AzHa2ADDe(double Az, double Ha, double *AD, double *Dec);
    5658    void   RechercheAzimutFinSuivi(double AD, double Dec, long int *azmin, long int *azmax);

  • BAORadio/libindi/libindi/communs/const.h

    r677 r682  
    88//////////////////////////////////////////
    99
     10
     11// ParamÚtres de l'instrument
     12
     13#define ED0 243.2
     14#define CD0 111.01
     15#define BC0 242.5
     16#define AE0 44.68
     17#define I00 81.0
     18#define CoeffMoteur0 0.078947
     19#define Thau0 20.2345
    1020
    1121// dimensions des tableaux

  • BAORadio/libindi/libindi/drivers/telescope/BAO.cpp

    r677 r682  
    1111
    1212#include "BAO.h"
    13 #include "../communs/alt2motor.h"
    1413
    1514
    … …  
    496495
    497496
     497
     498
     499
    498500/**************************************************************************************
    499501** En cas de changement de texte dans la boîte de dialogue (par exemple : changement du
    … …  
    634636                    return;
    635637                }
     638            }
     639            else if (chaine[0] == 'M')
     640            {
     641                if  (Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections >=3 )
     642                {
     643                    Sockets[targetAlignmentIP].AlignementAntenne->AlignementEnCours = 0;
     644                    Sockets[targetAlignmentIP].AlignementAntenne->CalculerMatriceCorrection(targetRA, targetDEC);
     645                }
     646                else
     647                {
     648                    Sockets[targetAlignmentIP].AlignementAntenne->Identity();
     649
     650                    Sockets[targetAlignmentIP].AlignementAntenne->Matrice_ok = false;
     651                }
     652
     653                IDSetText(&CommandTP, "Calcul des matrices de correction\n" );
     654            }
     655            else if (chaine[0] == 'O')
     656            {
     657                IDSetText(&CommandTP, "Optimisation de la geometrie de l antenne\n" );
     658               
     659                if (targetAlignmentIP != -1)
     660                {
     661                  Sockets[targetAlignmentIP].AlignementAntenne->OptimisationGeometrieAntenne();
     662                }               
    636663            }
    637664            else if (chaine[0] == 'C')
    … …  
    9811008                    targetDEC * Pidiv180;
    9821009            }
    983            
     1010
    9841011            for (int i=0; i<SocketsNumber; i++) if (Sockets[i].Connected)
    985             {
    986               if ( Sockets[i].AlignementAntenne->AlignementEnCours == 0 )
    987               {
    988                 Sockets[i].AlignementAntenne->CalculerMatriceCorrection(targetRA, targetDEC);
    989               }
    990             }
    991                
    992              
     1012                {
     1013                    if ( Sockets[i].AlignementAntenne->AlignementEnCours == 0 )
     1014                    {
     1015                        Sockets[i].AlignementAntenne->CalculerMatriceCorrection(targetRA, targetDEC);
     1016                    }
     1017                }
     1018
     1019
    9931020
    9941021            // on les affiche dans les logs
    … …  
    18181845
    18191846                    vect.z = 1.0;
    1820      
    1821 
    1822              
     1847
     1848
     1849
    18231850                    Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionAffine(&result, vect);
    18241851
    … …  
    18971924                // On applique la formule de Marc pour convertir la hauteur en nombre de pas codeur alt
    18981925
    1899                 Sockets[i].TargetPosition.y = (long int) Arrondi( Alt2Motor( targetAlt ) );
     1926                Sockets[i].TargetPosition.y = (long int) Arrondi( Sockets[i].AlignementAntenne->Alt2Motor( targetAlt ) );
    19001927
    19011928                //4000 pas pour 360° sur l'axe az

  • BAORadio/libindi/libindi/drivers/telescope/BAO.h

    r677 r682  
    136136    int  get_switch_index(ISwitchVectorProperty *sp);
    137137    void ADDEC2Motor(double newRA, double newDEC);
    138 
     138   
     139 
    139140    /*******************************************************/
    140141    /* Simulation Routines
    … …  
    257258    long int delta_ha;
    258259   
    259     
     260   
    260261};
    261262
Note: See TracChangeset for help on using the changeset viewer.