Changeset 684 for BAORadio


Ignore:
Timestamp:
May 24, 2012, 5:38:38 PM (12 years ago)
Author:
frichard
Message:
 
Location:
BAORadio/libindi/libindi/communs
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r682 r684  
    5151    for (int i=0; i< MAXALIGNEMENTANTENNE; i++)
    5252    {
    53 <<<<<<< .mine
    5453        ad[i]                           = 0.0;
    5554        de[i]                           = 0.0;
    … …  
    5857        tsl[i]                          = 0.0;
    5958        SelectionnePourCalculMatrice[i] = false;
    60 =======
    61         ad[i]                           = 0.0;
    62         de[i]                           = 0.0;
    63         delta_ad[i]                     = 0.0;
    64         delta_de[i]                     = 0.0;
    65         tsl[i]                          = 0.0;
    66         SelectionnePourCalculMatrice[i] = false;
    67 >>>>>>> .r680
    6859    }
    6960
    … …  
    183174    double temp[4][4];
    184175    double UnitVect[4][4];
    185    
     176
    186177    temp[1][1] = p2.x - p1.x;
    187178    temp[2][1] = p3.x - p1.x;
    … …  
    221212    double EQLMN2[4][4];
    222213    double EQMI_T[4][4];
    223    
     214
    224215    Coord a1, a2, a3, m1, m2, m3;
    225    
     216
    226217    AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y);
    227218    AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y);
    228219    AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y);
    229220
    230 <<<<<<< .mine
    231     Coord a1, a2, a3, m1, m2, m3;
    232 =======
    233221    AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y);
    234222    AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
    235223    AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y);
    236    
     224
    237225    //construit les matrices EQLMN1 & 2
    238 >>>>>>> .r680
    239 
    240 <<<<<<< .mine
    241     AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y);
    242     AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y);
    243     AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y);
    244 =======
     226
    245227    Calculer_Matrice_LMN(m1, m2, m3);
    246 >>>>>>> .r680
    247 
    248 <<<<<<< .mine
    249     AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y);
    250     AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
    251     AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y);
    252 =======
     228
    253229    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
    269230
    270231    Calculer_Matrice_LMN(a1, a2, a3);
    … …  
    377338    double EQMQ[4][4];
    378339
    379 <<<<<<< .mine
    380340    Coord a1, a2, a3, m1, m2, m3, c1, c2;
    381 =======
    382     Coord a1, a2, a3, m1, m2, m3, c1, c2;
    383    
     341
    384342    AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y);
    385343    AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y);
    … …  
    389347    AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
    390348    AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y);
    391    
    392     /*c1.x=(a1.x+a2.x+a3.x)/3.0;
    393     c1.y=(a1.y+a2.y+a3.y)/3.0;
    394    
    395     c2.x=(m1.x+m2.x+m3.x)/3.0;
    396     c2.y=(m1.y+m2.y+m3.y)/3.0;
    397    
    398     a1.x-=c1.x;
    399     a1.y-=c1.y;
    400     a2.x-=c1.x;
    401     a2.y-=c1.y;
    402     a3.x-=c1.x;
    403     a3.y-=c1.y;
    404    
    405     m1.x-=c2.x;
    406     m1.y-=c2.y;
    407     m2.x-=c2.x;
    408     m2.y-=c2.y;
    409     m3.x-=c2.x;
    410     m3.y-=c2.y;*/
    411    
    412    
    413    
    414    
     349
     350
    415351    //Construit les matrices EQMP et EQMQ
    416 >>>>>>> .r680
    417 
    418 <<<<<<< .mine
    419     AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y);
    420     AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y);
    421     AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y);
    422 =======
     352
    423353    Calculer_Matrice_GETPQ(m1, m2, m3);
    424 >>>>>>> .r680
    425 
    426 <<<<<<< .mine
    427     AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y);
    428     AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
    429     AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y);
    430 =======
     354
    431355    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
    448356
    449357    Calculer_Matrice_GETPQ(a1, a2, a3);
    … …  
    476384    MATRICE[2][1] = (EQMI[2][1] * EQMQ[1][1]) + (EQMI[2][2] * EQMQ[2][1]);
    477385    MATRICE[2][2] = (EQMI[2][1] * EQMQ[1][2]) + (EQMI[2][2] * EQMQ[2][2]);
    478    
    479    
    480    
     386
    481387
    482388
    … …  
    486392    VECT_OFFSET.y =0.0;//m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2]));
    487393
    488 <<<<<<< .mine
    489394    if (x + y == 0 )
    490395    {
    … …  
    495400        return  PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y);
    496401    }
    497 =======
    498    if (x + y == 0 )
    499     {
    500         return 0;
    501     }
    502     else
    503     {
    504         return  PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y);
    505     }
    506 >>>>>>> .r680
    507402}
    508403
    … …  
    676571
    677572
    678 <<<<<<< .mine
    679573double Alignement::Determinant()
    680574{
    681575    double Det;
    682 =======
    683 double Alignement::Determinant()
    684 {
    685     double Det;
    686    
     576
    687577    Det = MATRICE[1][1] * ((MATRICE[2][2] * MATRICE[3][3]) - (MATRICE[3][2] * MATRICE[2][ 3]));
    688578    Det = Det - (MATRICE[1][2] * ((MATRICE[2][1] * MATRICE[3][3]) - (MATRICE[3][1] * MATRICE[2][3])));
    689579    Det = Det + (MATRICE[1][3] * ((MATRICE[2][1] * MATRICE[3][2]) - (MATRICE[3][1] * MATRICE[2][2])));
    690 >>>>>>> .r680
    691 
    692 <<<<<<< .mine
    693     Det = MATRICE[1][1] * ((MATRICE[2][2] * MATRICE[3][3]) - (MATRICE[3][2] * MATRICE[2][ 3]));
    694     Det = Det - (MATRICE[1][2] * ((MATRICE[2][1] * MATRICE[3][3]) - (MATRICE[3][1] * MATRICE[2][3])));
    695     Det = Det + (MATRICE[1][3] * ((MATRICE[2][1] * MATRICE[3][2]) - (MATRICE[3][1] * MATRICE[2][2])));
    696 =======
     580
    697581    return Det;
    698582}
    699 >>>>>>> .r680
    700 
    701 <<<<<<< .mine
    702     return Det;
    703 }
    704583
    705584
    … …  
    714593}
    715594
    716 =======
    717 
    718 
    719 void Alignement::AzHa2XY(double az, double ha, double *x, double *y)
    720 {
    721     double r = Pidiv2 - ha;
    722 
    723     *x = r * cos(az);
    724 
    725     *y = r * sin(az);
    726 }
    727 
    728 >>>>>>> .r680
    729595/**************************************************************************************
    730596** Calcule la surface d'un triangle de coordonnées (px1,py1) (px2, py2) (px3, py3)
    … …  
    735601{
    736602    double ta;
    737    
     603
    738604    double pxx1, pyy1, pxx2, pyy2, pxx3, pyy3;
    739605
    740 <<<<<<< .mine
    741     double pxx1, pyy1, pxx2, pyy2, pxx3, pyy3;
    742 =======
    743606    AzHa2XY(px1, py1, &pxx1, &pyy1);
    744 >>>>>>> .r680
    745 
    746 <<<<<<< .mine
    747     AzHa2XY(px1, py1, &pxx1, &pyy1);
    748607
    749608    AzHa2XY(px2, py2, &pxx2, &pyy2);
    … …  
    753612    ta = (((pxx2 * pyy1) - (pxx1 * pyy2)) ) + (((pxx3 * pyy2) - (pxx2 * pyy3))  ) + (((pxx1 * pyy3) - (pxx3 * pyy1))  );
    754613
    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
    763614    return  fabs(ta) / 2.0;
    764615}
    … …  
    788639    AfficherLog(os.str().c_str(), true);
    789640
    790 <<<<<<< .mine
    791641    /* if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false;
    792642      if ( DistanceAngulaireEntre2Points(px, py, px2, py2) > 1.2 ) return false;
    793643      if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false;*/
    794 =======
    795   /* if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false;
    796     if ( DistanceAngulaireEntre2Points(px, py, px2, py2) > 1.2 ) return false;
    797     if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false;*/
    798 >>>>>>> .r680
    799644
    800645    return ( fabs(ta - t1 - t2 - t3) < 1e-10 );
    … …  
    1122967            os << "Point " << map[i] << "  d=" << distances[i] * N180divPi << "°\n";
    1123968        }
    1124 <<<<<<< .mine
    1125969
    1126970        for (int i=0; i<nbrcorrections; i++)
    1127 =======
    1128        
    1129         for (int i=0; i<nbrcorrections; i++)
    1130 >>>>>>> .r680
    1131971        {
    1132972            for (int j=i+1; j<nbrcorrections; j++)
    … …  
    12001040        os << "\nUtilisation du triangle : " << map[best1] << " " << map[best2] << " " << map[best3]  << "\n" ;
    12011041
    1202 <<<<<<< .mine
    12031042        // if (MethodeAlignement == SIMPLE)
    1204 =======
    1205        // if (MethodeAlignement == SIMPLE)
    1206 >>>>>>> .r680
    12071043        {
    12081044            c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL());
    … …  
    12181054            c3.z = 1.0;
    12191055        }
    1220 <<<<<<< .mine
    12211056        /*    else
    12221057            {
    … …  
    12241059                c1.y = de[map[best1]];
    12251060                c1.z = 1.0;
    1226 =======
    1227     /*    else
    1228         {
    1229             c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL());
    1230             c1.y = de[map[best1]];
    1231             c1.z = 1.0;
    1232 >>>>>>> .r680
    1233 
    1234 <<<<<<< .mine
     1061
    12351062                c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL());
    12361063                c2.y = de[map[best2]];
    12371064                c2.z = 1.0;
    1238 =======
    1239             c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL());
    1240             c2.y = de[map[best2]];
    1241             c2.z = 1.0;
    1242 >>>>>>> .r680
    1243 
    1244 <<<<<<< .mine
     1065
    12451066                c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL());
    12461067                c3.y = de[map[best3]];
    … …  
    12501071        m1.x = VerifAngle(delta_ad[map[best1]] - tsl[map[best1]] + GetTSL());
    12511072        m1.y = delta_de[map[best1]];
    1252 =======
    1253             c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL());
    1254             c3.y = de[map[best3]];
    1255             c3.z = 1.0;
    1256         }*/
    1257      
    1258         m1.x = VerifAngle(delta_ad[map[best1]] - tsl[map[best1]] + GetTSL());
    1259         m1.y = delta_de[map[best1]];
    1260 >>>>>>> .r680
    12611073        m1.z = 1.0;
    12621074
    … …  
    12981110
    12991111
    1300 <<<<<<< .mine
    13011112    for (int i=0; i<nbrcorrections; i++) SelectionnePourCalculMatrice[i] = false;
    1302 =======
    1303     for (int i=0; i<nbrcorrections; i++) SelectionnePourCalculMatrice[i] = false;
    1304    
     1113
    13051114    SelectionnePourCalculMatrice[map[best1]] = true;
    13061115    SelectionnePourCalculMatrice[map[best2]] = true;
    13071116    SelectionnePourCalculMatrice[map[best3]] = true;
    1308    
    1309 >>>>>>> .r680
    1310 
    1311 <<<<<<< .mine
    1312     SelectionnePourCalculMatrice[map[best1]] = true;
    1313     SelectionnePourCalculMatrice[map[best2]] = true;
    1314     SelectionnePourCalculMatrice[map[best3]] = true;
    1315 
    1316 
    1317 =======
    1318     //Vérifications supp
    1319     /*
    1320     Coord result, mm1;
    1321     double targetAz, targetAlt;
    1322 
    1323     os << "\n\n\n" << GetLatitude()*N180divPi << "      " << GetLongitude()*N180divPi << "\n";
    1324     os << GetPression() << "      " << GetTemperature() << "\n";
    1325     os << GetHeure() << ":" << GetMin() << ":" << GetSec() << "\n";
    1326     os << DHMS(GetTSL()*N180divPi, true) << "\n\n";
    1327 
    1328       Azimut(c3.x, c3.y, &mm1.x, &mm1.y);
    1329 
    1330     os << mm1.x*N180divPi << "   "  <<  mm1.y*N180divPi << "\n";
    1331 
    1332 
    1333     Azimut(m3.x, m3.y, &mm1.x, &mm1.y);
    1334 
    1335     os << mm1.x*N180divPi << "   "  <<  mm1.y*N180divPi << "\n";
    1336 
    1337 
    1338     Azimut(c3.x, c3.y, &mm1.x, &mm1.y);
    1339 
    1340     double x=cos(mm1.x) * cos(mm1.y);
    1341     double y=sin(mm1.x) * cos(mm1.y);
    1342     double z=sin(mm1.y);
    1343     mm1.x=x;
    1344     mm1.y=y;
    1345     mm1.z=z;
    1346 
    1347     AppliquerMatriceCorrectionSimple(&result, mm1);
    1348 
    1349     if (result.x != 0.0)
    1350     {
    1351         targetAz = atan( result.y / result.x );
    1352 
    1353         if (result.x < 0) targetAz+=Pi;
    1354     }
    1355     else targetAz = Pidiv2;
    1356 
    1357     targetAz  = VerifAngle(targetAz);
    1358 
    1359     targetAlt = asin(result.z);
    1360 
    1361     os << targetAz*N180divPi << "   "  <<  targetAlt*N180divPi << "\n";
    1362     */
    1363 
    1364 
    1365 
    1366 >>>>>>> .r680
     1117
     1118
    13671119    //Afficher les messages de cette fonction
    13681120
    … …  
    13821134
    13831135    // sauvegarder la position courante
    1384 <<<<<<< .mine
    13851136    // long pos = fichier.tellg();
    1386 =======
    1387    // long pos = fichier.tellg();
    1388 >>>>>>> .r680
    13891137    // se placer en fin de fichier
    13901138    fichier.seekg( 0 , std::ios_base::end );
    … …  
    14381186
    14391187
    1440 <<<<<<< .mine
    14411188    nbrcorrections = 0;
    14421189
    14431190    for (int j=0; j < MAXALIGNEMENTANTENNE; j++)
    1444 =======
    1445     nbrcorrections = 0;
    1446    
    1447     for (int j=0; j < MAXALIGNEMENTANTENNE; j++)
    1448 >>>>>>> .r680
    14491191    {
    14501192        os2 << "ad " << j;
    … …  
    14851227            // -> on les applique...
    14861228
    1487 <<<<<<< .mine
    1488 =======
    1489            
    1490 >>>>>>> .r680
    1491 
    1492 <<<<<<< .mine
     1229
    14931230
    14941231            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
    14981232            {
    14991233                ad[nbrcorrections] = atof(ad_data);
    … …  
    15071241                tsl[nbrcorrections] = atof(tsl_data);
    15081242
    1509 <<<<<<< .mine
    15101243                os2 << "Correction antenne ip=" << IP <<  " ad=" << ad[nbrcorrections] << " de=" << de[nbrcorrections] << " deltaAD=" <<
    15111244                    delta_ad[nbrcorrections] << " deltaDe=" << delta_de[nbrcorrections] << " tsl=" << tsl[nbrcorrections] << "\n";
    1512 =======
    1513                 os2 << "Correction antenne ip=" << IP <<  " ad=" << ad[nbrcorrections] << " de=" << de[nbrcorrections] << " deltaAD=" <<
    1514                 delta_ad[nbrcorrections] << " deltaDe=" << delta_de[nbrcorrections] << " tsl=" << tsl[nbrcorrections] << "\n";
    1515 >>>>>>> .r680
    15161245
    15171246                AfficherLog(&os2, true);
    15181247
    15191248                modificationAlignement = true;
    1520 <<<<<<< .mine
    15211249
    15221250                nbrcorrections++;
    15231251            }
    1524 =======
    1525                
    1526                 nbrcorrections++;
    1527             }           
    1528 >>>>>>> .r680
    15291252        }
    15301253
    … …  
    17601483    }
    17611484
    1762 <<<<<<< .mine
    17631485    for (int j = 0; j < nbrcorrections; j++) if (ad[j]!=0.0 && de[j]!=0.0)
    17641486        {
    … …  
    17711493
    17721494            writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
    1773 =======
    1774     for (int j = 0; j < nbrcorrections; j++) if (ad[j]!=0.0 && de[j]!=0.0)
    1775     {
    1776         os << "ad " << j;
    1777         key     = os.str();
    1778         os.str("");
    1779         os << ad[j];
    1780         value = os.str();
    1781         os.str("");
    1782 >>>>>>> .r680
    17831495
    17841496            os << "de " << j;

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

    r682 r684  
    9292
    9393    double Surface_Triangle(double px1, double py1, double px2, double py2, double px3, double py3);
    94 <<<<<<< .mine
    9594    void   AzHa2XY(double az, double ha, double *x, double *y);
    9695    bool   PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3);
    97 =======
    98     void AzHa2XY(double az, double ha, double *x, double *y);
    99     bool PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3);
    100 >>>>>>> .r680
    101    
    102     double Determinant();
    10396
    10497    inline double Determinant();
    … …  
    120113    long delta_az_polar;                        // Correction en azimut de l'orientation de l'étoile polaire
    121114    // C'est la premiÚre étape de l'alignement dans les mode AFFINE et TAKI
    122    
    123     long int deltaAZ;                           // delta en azimut et en hauteur pour une correction à la raquette
    124     long int deltaHA;                           // hors procédure d'alignement
    125    
    126     bool SelectionnePourCalculMatrice[MAXALIGNEMENTANTENNE];
    127115
    128116    long int deltaAZ;                           // delta en azimut et en hauteur pour une correction à la raquette

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

    r682 r684  
    5353    string DHMS(double mema, bool HMS);
    5454     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);
    5755    void   AzHa2ADDe(double Az, double Ha, double *AD, double *Dec);
    5856    void   RechercheAzimutFinSuivi(double AD, double Dec, long int *azmin, long int *azmax);
Note: See TracChangeset for help on using the changeset viewer.