Changeset 7788 for trunk/MagicSoft


Ignore:
Timestamp:
07/12/06 03:00:16 (18 years ago)
Author:
tbretz
Message:
*** empty log message ***
Location:
trunk/MagicSoft/Cosy
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/MagicSoft/Cosy/Changelog

    r7787 r7788  
    3737       is neccessary in root 4.04/02g to make cosy work is
    3838       unknown. Anyhow it makes switching the cameras more robust
     39
     40   * cosy.cc:
     41     - updated writing log-files
     42     - implemented sanity check for batch mode
     43
     44   * gui/MGAccuracy.cc, gui/MGStarg.cc:
     45     - use GetabsDev from MAstro
     46     - scale azimuth deviation to real distance on the sky
     47
     48   * main/MCosy.[h,cc]:
     49     - updated writing log-files
     50     - do no perfect position in case of move'n'track
     51     - implemented WM_PREPS for predefined positions
     52     - unified WM_TRACK and WM_GRB
     53     - updated GetFileName
     54
     55   * main/MStarguider.cc:
     56     - undef EXPERT
     57     - some layout changes
     58     - set rotation angle of starguider camera to -0.4deg
     59     - unified FindStar and FindStarCircle
     60     - updated writing log-files
     61     - to calc skycenter the X-offset must be subtracted
     62
     63   * tcpip/MDriveCom.[h,cc]:
     64     - implemented CommandPREPS
     65     - implemented CommandARM
     66
     67   * videodev/FilterLed.[h,cc]:
     68     - unified FindStar and FindStarCircle
     69     - fixed algorithm FindStarCircle (it was not working for
     70       bright stars and didn't take care of the edge of the
     71       image!)
     72     - fixed a long outstanding bug which accessed some memory
     73       outside the image due to a wrong logical condition
    3974
    4075
  • trunk/MagicSoft/Cosy/cosy.cc

    r4105 r7788  
    4848    // this must move to MGCosy !!!!
    4949    //
    50     const TString name = MCosy::GetFileName("log/cosy_%s.log");
     50    const TString name = MCosy::GetFileName("log", "cosy", "log");
    5151    cout << "Open Logfile: " << name << endl;
    5252
     
    6565    // FIXME: Fails deleteing something in TGClient::fWlist
    6666    TApplication *app=new TApplication("App", &argc, argv);
     67
     68    if (gROOT->IsBatch())
     69    {
     70        cout << "ERROR - Cannot run in Batch mode!" << endl;
     71        return 0;
     72    }
    6773
    6874    //
  • trunk/MagicSoft/Cosy/gui/MGAccuracy.cc

    r4076 r7788  
    2020#include "coord.h"
    2121#include "MTime.h"
     22#include "MAstro.h"
    2223
    2324ClassImp(MGAccuracy);
     
    238239void MGAccuracy::Update(Float_t pzd, Float_t azd, Float_t aaz)
    239240{
    240     const Float_t d2r = TMath::Pi()/180.;
    241 
    242     pzd *= d2r;
    243     azd *= d2r;
    244     aaz *= d2r;
    245 
    246     const double el = TMath::Pi()/2-pzd;
    247 
    248     const double dphi2 = aaz/2.;
    249     const double cos2  = cos(dphi2)*cos(dphi2);
    250     const double sin2  = sin(dphi2)*sin(dphi2);
    251     const double d     = cos(azd)*cos2 - cos(2*el)*sin2;
    252 
    253     //
    254     // Original:
    255     //   cos(Zd1)*cos(Zd2)+sin(Zd1)*sin(Zd2)*cos(dAz)
    256     //
    257     // Correct:
    258     //   const double d = cos(azd)*cos2 - cos(el1+el2)*sin2;
    259     //
    260     // Estimated:
    261     //   const double d = cos(azd)*cos2 - cos(2*el)*sin2;
    262     //
    263 
    264     double dist = acos(d)*TMath::RadToDeg();
     241    const double dist = MAstro::GetDevAbs(pzd, azd, aaz);
    265242
    266243    UpdateText(dist);
     
    303280}
    304281
    305 void MGAccuracy::Update(ZdAz &pos, ZdAz &acc)
    306 {
    307     UpdateCross(acc.Az()*3600., acc.Zd()*3600.);
    308     Update(pos.Zd(), acc.Zd(), acc.Az());
     282void MGAccuracy::Update(ZdAz &pos, ZdAz &dev)
     283{
     284    // Estimate the distance in az direction on the camera plane
     285    const double daz = MAstro::GetDevAbs(pos.Zd(), 0, dev.Az())*3600.;
     286
     287    //cout << "--> T: " << dev.Az()*60 << " " << dev.Zd()*60. << endl;
     288
     289    UpdateCross(TMath::Sign(daz, dev.Az()), dev.Zd()*3600.);
     290    Update(pos.Zd(), dev.Zd(), dev.Az());
    309291
    310292    UpdateCanvas();
  • trunk/MagicSoft/Cosy/gui/MGStarg.cc

    r4865 r7788  
    1616#include "coord.h"
    1717#include "MTime.h"
     18#include "MAstro.h"
    1819
    1920ClassImp(MGStarg);
     
    3637    text.SetTextAlign(11);  // left, bottom (s.TAttText)
    3738    text.SetTextColor(3);
    38     text.DrawText(160, -220, "0.0125 deg");
     39    text.DrawText(220, -220, "0.75'");
    3940
    4041    text.SetTextColor(5);
    41     text.DrawText(160, -250, "0.025 deg");
     42    text.DrawText(220, -250, "1.50'");
    4243
    4344    text.SetTextColor(2);
    44     text.DrawText(160, -280, "0.05 deg");
     45    text.DrawText(220, -280, "3.00'");
    4546
    4647
     
    218219void MGStarg::Update(Float_t pzd, Float_t azd, Float_t aaz)
    219220{
    220     const Float_t d2r = TMath::Pi()/180.;
    221 
    222     pzd *= d2r;
    223     azd *= d2r;
    224     aaz *= d2r;
    225 
    226     const double el = TMath::Pi()/2-pzd;
    227 
    228     const double dphi2 = aaz/2.;
    229     const double cos2  = cos(dphi2)*cos(dphi2);
    230     const double sin2  = sin(dphi2)*sin(dphi2);
    231     const double d     = cos(azd)*cos2 - cos(2*el)*sin2;
    232 
    233     double dist = acos(d)*TMath::RadToDeg();
     221    const double dist = MAstro::GetDevAbs(pzd, azd, aaz);
    234222
    235223    UpdateText(dist);
     
    269257}
    270258
    271 void MGStarg::Update(ZdAz &pos, ZdAz &acc)
    272 {
    273 
    274     UpdateCross(acc.Az()*3600., acc.Zd()*3600.);
    275     Update(pos.Zd(), acc.Zd(), acc.Az());
     259void MGStarg::Update(ZdAz &pos, ZdAz &dev)
     260{
     261    // Estimate the distance in az direction on the camera plane
     262    const double daz = MAstro::GetDevAbs(pos.Zd(), 0, dev.Az())*3600.;
     263
     264    //cout << "--> S: " << dev.Az()*60 << " " << dev.Zd()*60. << endl;
     265
     266    UpdateCross(TMath::Sign(daz, dev.Az()), dev.Zd()*3600.);
     267    Update(pos.Zd(), dev.Zd(), dev.Az());
    276268
    277269    UpdateCanvas();
    278270}
    279 
    280 
    281 
    282 
    283 
    284 
    285 
    286 
    287 
    288 
  • trunk/MagicSoft/Cosy/main/MCosy.cc

    r7614 r7788  
    401401//
    402402    point.SetPointAccDec(0.2, 0.1);
     403
    403404    point.SetPointVelocity(0.1);
    404405
     
    634635                // open tpoint file
    635636                //
    636                 const TString name = GetFileName("tpoint/old-tpoint_%s.txt");
     637                const TString name = GetFileName("tpoint", "old-tpoint", "txt");
    637638                cout << "TPoint-Cosy File ********* " << name << " ********** " << endl;
    638639
     
    675676
    676677            ZdAz dest = *((ZdAz*)mp) * kDeg2Rad;
    677             if (!SetPosition(dest))
     678            if (!SetPosition(dest, kTRUE))
    678679                return (void*)0x1234;
    679680
     
    686687        //cout << "WM_TrackPosition: done. (return 0xabcd)" << endl;
    687688        return (void*)0xabcd;
    688 
     689/*
     690    case WM_ARM:
     691        //cout << "WM_Position: start." << endl;
     692        {
     693            if (!CheckNetwork())
     694                return (void*)0xebb0;
     695
     696            const bool arm = *((bool*)mp);
     697            if (arm)
     698            {
     699                fMac1->Arm();
     700                fMac2->Arm();
     701                cout << "ARMED" << endl;
     702            }
     703            else
     704            {
     705                fMac1->Disarm();
     706                fMac2->Disarm();
     707                cout << "DISARMED" << endl;
     708            }
     709        }
     710        //cout << "WM_Position: done. (return 0x7777)" << endl;
     711        return (void*)0x9999;
     712  */
    689713    case WM_POSITION:
    690714        //cout << "WM_Position: start." << endl;
     
    711735        return (void*)0x7777;
    712736
     737    case WM_PREPS:
     738        //cout << "WM_Track: START" << endl;
     739        {
     740            if (!CheckNetwork())
     741                return (void*)0xebb0;
     742
     743            const char *preps = (const char*)mp;
     744            cout << "Preposition command to " << preps << " received." << endl;
     745
     746            ifstream fin("prepos.txt");
     747            if (!fin)
     748            {
     749                cout << "ERROR: cannot open prepos.txt." << endl;
     750                return (void*)0xebb1;
     751            }
     752
     753            while (1)
     754            {
     755                Double_t zd, az;
     756                fin >> zd >> az;
     757
     758                TString str;
     759                str.ReadLine(fin);
     760                if (!fin)
     761                    break;
     762
     763                str.ToLower();
     764
     765                if (str.Strip(TString::kBoth)==preps)
     766                {
     767                    ZdAz dest(zd, az);
     768                    SetPosition(dest*kDeg2Rad);
     769                    return (void*)0x7979;
     770                }
     771                cout << "ERROR - Requested preposition not found in file..." << endl;
     772            }
     773        }
     774        //cout << "WM_Track: done. (return 0x8888)" << endl;
     775        return (void*)0x7878;
     776
    713777    case WM_TESTSE:
    714778        //cout << "WM_TestSe: start." << endl;
     
    730794
    731795    case WM_TRACK:
    732         //cout << "WM_Track: START" << endl;
     796    case WM_GRB:
     797        //cout << "WM_Track/GRB: START" << endl;
    733798        {
    734799            RaDec dest = ((RaDec*)mp)[0];
     
    737802            if (!CheckNetwork())
    738803                return (void*)0xebb0;
    739             TrackPosition(dest*kDeg2Rad);
     804
     805            if (msg==WM_TRACK)
     806                TrackPosition(dest*kDeg2Rad);
     807            else
     808                TrackPositionGRB(dest*kDeg2Rad);
    740809        }
    741         //cout << "WM_Track: done. (return 0x8888)" << endl;
    742         return (void*)0x8888;
    743 
    744     case WM_GRB:
    745         //cout << "WM_Track: START" << endl;
    746         {
    747             RaDec dest = ((RaDec*)mp)[0];
    748             if (fStarguider)
    749                 fStarguider->SetPointingPosition(((RaDec*)mp)[1]);
    750             if (!CheckNetwork())
    751                 return (void*)0xebb0;
    752             TrackPositionGRB(dest*kDeg2Rad);
    753         }
    754         //cout << "WM_Track: done. (return 0x8888)" << endl;
     810        //cout << "WM_Track/GRB: done. (return 0x8888)" << endl;
    755811        return (void*)0x8888;
    756812
     
    11781234    avail |= (fZd2  && !fZd2->IsZombieNode())  ? 0x10 : 0;
    11791235    avail |= (fAz   && !fAz->IsZombieNode())   ? 0x20 : 0;
     1236//    avail |= (!(fStatus&MDriveCom::kError) && 1 ? 0x40 : 0;
    11801237
    11811238    if (HasError())
     
    14711528*/
    14721529
    1473 TString MCosy::GetFileName(const char *fmt)
     1530TString MCosy::GetFileName(const char *path, const char *name, const char *ext)
    14741531{
    14751532    // FIXME: Timeout missing
     1533
    14761534    while (1)
    14771535    {
    14781536        MTime time(-1);
    1479         const TString name = Form(fmt, (const char*)time.GetFileName());
    1480         if (gSystem->AccessPathName(name, kFileExists))
    1481             return name;
    1482             break;
     1537
     1538        // This is the full qualified date which is part of the name
     1539        const TString clock = time.GetStringFmt("%y%m%d_%H%M%S");
     1540
     1541        // This gives the night in which the date belongs to
     1542        time.SetMjd(TMath::Nint(time.GetMjd()));
     1543
     1544        const TString night = time.GetStringFmt("%Y_%m_%d");
     1545
     1546        const TString dir   = Form("%s/%s", path, night.Data());
     1547        const TString fname = Form("%s_%s.%s", name, clock.Data(), ext);
     1548
     1549        const TString full  = Form("%s/%s", dir.Data(), fname.Data());
     1550
     1551        gSystem->mkdir(dir, kTRUE);
     1552
     1553        if (gSystem->AccessPathName(full, kFileExists))
     1554            return full;
     1555
     1556        break;// !!!!!!!!!!!!!!!!!!!!!!!
    14831557
    14841558        usleep(1000);
     
    14981572    const Int_t id6 = env.GetValue("Az_Id-SE",   6); //6
    14991573
    1500     TString name = GetFileName("rep/cosy_%s.rep");
     1574    TString name = GetFileName("rep", "cosy", "rep");
    15011575    cout << "Open Repfile: " << name << endl;
    15021576    fOutRep = new MLog(name, kTRUE);
  • trunk/MagicSoft/Cosy/main/MCosy.h

    r6841 r7788  
    3838#define WM_ENDSWITCH    0x1010
    3939#define WM_GRB          0x1011
     40#define WM_PREPS        0x1012
     41#define WM_ARM          0x1013
    4042
    4143class ShaftEncoder;
     
    187189    void SetStarguider(MStarguider *s) { fStarguider = s; }
    188190
    189     static TString GetFileName(const char *name);
     191    static TString GetFileName(const char *path, const char *name, const char *ext);
    190192
    191193    MGCosy *GetWin() { return fWin; }
  • trunk/MagicSoft/Cosy/main/MStarguider.cc

    r7785 r7788  
     1#undef EXPERT
    12#undef EXPERT
    23
     
    335336
    336337    fCZdAz = new MGCoordinates(this, kETypeZdAz, kFALSE);
    337     fCZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+581+12);
     338    fCZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+581+20-4);
    338339    AddFrame(fCZdAz);
    339340    fList->Add(fCZdAz);
    340341
    341342    fPZdAz = new MGCoordinates(this, kETypeZdAz, kFALSE);
    342     fPZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+627+2*12);
     343    fPZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+627+2*20-4);
    343344    AddFrame(fPZdAz);
    344345    fList->Add(fPZdAz);
    345346
    346347    fDZdAz = new MGCoordinates(this, kETypeZdAz, kFALSE);
    347     fDZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+673+3*12);
     348    fDZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+673+3*20-4);
    348349    AddFrame(fDZdAz);
    349350    fList->Add(fDZdAz);
    350351
    351352    fSZdAz = new MGCoordinates(this, kETypeZdAz, kFALSE);
    352     fSZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+719+4*12);
     353    fSZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+719+4*20-4);
    353354    AddFrame(fSZdAz);
    354355    fList->Add(fSZdAz);
    355356
    356357    fTPoint = new TGTextButton(this, "TPoint");
    357     fTPoint->Move(4, fMenu->GetDefaultHeight()+722+3*12+25);
     358    fTPoint->Move(4, fMenu->GetDefaultHeight()+722+3*15+15);
    358359    fTPoint->AllowStayDown(kTRUE);
    359360    AddFrame(fTPoint);
     
    361362
    362363    fStargTPoint = new TGTextButton(this, "StargTPoint");
    363     fStargTPoint->Move(240+12+20, fMenu->GetDefaultHeight()+785);
     364    fStargTPoint->Move(240+12+28, fMenu->GetDefaultHeight()+785);
    364365    fStargTPoint->AllowStayDown(kTRUE);
    365366    AddFrame(fStargTPoint);
     
    368369    fFps = new TGLabel(this, "---fps");
    369370    fFps->SetTextJustify(kTextRight);
    370     fFps->Move(650-440, fMenu->GetDefaultHeight()+619+13+60+20);
     371    fFps->Move(650-495, fMenu->GetDefaultHeight()+619+13+60+20+2);
    371372    AddFrame(fFps);
    372373    fList->Add(fFps);
    373374
    374     fPosZoom = new TGLabel(this, "----.--d/----.--d (----, ----)");
    375     fPosZoom->SetTextJustify(kTextRight);
     375    fPosZoom = new TGLabel(this, "(----, ----) ----.--d/----.--d");
     376    fPosZoom->SetTextJustify(kTextLeft);
    376377    fPosZoom->Move(4, fMenu->GetDefaultHeight()+765);
    377378    AddFrame(fPosZoom);
     
    386387    TGLabel *l = new TGLabel(this, "arcsec/pix");
    387388    l->SetTextJustify(kTextLeft);
    388     l->Move(605-400, fMenu->GetDefaultHeight()+619+13+60);
     389    l->Move(606-412, fMenu->GetDefaultHeight()+619+13+60);
    389390    AddFrame(l);
    390391    fList->Add(l);
     
    392393    l = new TGLabel(this, "deg");
    393394    l->SetTextJustify(kTextLeft);
    394     l->Move(605-410, fMenu->GetDefaultHeight()+619-10+60);
     395    l->Move(606-412, fMenu->GetDefaultHeight()+619-10+60);
    395396    AddFrame(l);
    396397    fList->Add(l);
     
    398399    l = new TGLabel(this, "Telescope pointing at");
    399400    l->SetTextJustify(kTextLeft);
    400     l->Move(240+12+20, fMenu->GetDefaultHeight()+584-5);
     401    l->Move(240+12+20+7, fMenu->GetDefaultHeight()+584-5);
    401402    AddFrame(l);
    402403    fList->Add(l);
     
    404405    l = new TGLabel(this, "Starguider position");
    405406    l->SetTextJustify(kTextLeft);
    406     l->Move(240+12+20, fMenu->GetDefaultHeight()+630+12-5);
     407    l->Move(240+12+20+7, fMenu->GetDefaultHeight()+630+20-5);
    407408    AddFrame(l);
    408409    fList->Add(l);
     
    410411    l = new TGLabel(this, "Misspointing");
    411412    l->SetTextJustify(kTextLeft);
    412     l->Move(240+12+20, fMenu->GetDefaultHeight()+676+2*12-5);
     413    l->Move(240+12+20+7, fMenu->GetDefaultHeight()+676+2*20-5);
    413414    AddFrame(l);
    414415    fList->Add(l);
     
    417418    l = new TGLabel(this, "Misspointing/FindStar (Experts Only!)");
    418419    l->SetTextJustify(kTextLeft);
    419     l->Move(240+12+20, fMenu->GetDefaultHeight()+722+3*12-5);
     420    l->Move(240+12+20, fMenu->GetDefaultHeight()+722+3*20-5);
    420421    AddFrame(l);
    421422    fList->Add(l);
     
    436437    fList->Add(fPixSize);
    437438
    438     fAngle = new TGTextEntry(this, "         0", IDM_kAngle);
     439    const Double_t angle = -0.4;
     440    fSao->SetRotationAngle(angle);
     441
     442    txt = "";
     443    txt += angle;
     444
     445    fAngle = new TGTextEntry(this, txt, IDM_kAngle);
    439446    fAngle->SetAlignment(kTextCenterX);
    440447    fAngle->Move(547-410, fMenu->GetDefaultHeight()+617-10+60);
     
    13851392    {
    13861393        // open tpoint file
    1387         const TString name = MCosy::GetFileName("tpoint/starg_%s.txt");
     1394        const TString name = MCosy::GetFileName("tpoint", "starg", "txt");
    13881395        cout << "TPoint-Starg File ********* " << name << " ********** " << endl;
    13891396
     
    14511458    // Try to find Led in this area
    14521459    Leds leds;
    1453     f.FindStarCircle(leds, (Int_t)SearchCenter.X(), (Int_t)SearchCenter.Y());
     1460    f.FindStar(leds, (Int_t)SearchCenter.X(), (Int_t)SearchCenter.Y(), true);
    14541461
    14551462    // Check whether star found
     
    14701477    if (!fOutRq)
    14711478    {
    1472         const TString name = MCosy::GetFileName("tpoint/starg_roquelamp_%s.txt");
     1479        const TString name = MCosy::GetFileName("tpoint", "roquelamp", "txt");
    14731480        cout << "Starg_RoqueLamp File ********* " << name << " ********** " << endl;
    14741481        fOutRq = new ofstream(name);
     
    14761483    }
    14771484
    1478 
    14791485    return relroquepos;
    14801486}
    1481  
    14821487
    14831488ZdAz MStarguider::FindStar(FilterLed &f, FilterLed &f2, Ring &center, MTime &t, Double_t cut, Double_t box, Double_t scalefactor = 1.0)
     
    14891494    // Try to find Led in this area
    14901495    Leds leds;
    1491     f.FindStarCircle(leds, (Int_t)center.GetX(), (Int_t)center.GetY());
     1496    f.FindStar(leds, (Int_t)center.GetX(), (Int_t)center.GetY(), true);
    14921497
    14931498    if (leds.GetEntries()<0)
     
    15051510        return ZdAz(.0,.0);
    15061511    }
    1507 
    15081512    cout << "Found star @ " << flush;
    15091513    star->Print();
     
    15611565        // open tpoint file
    15621566        //
    1563         const TString name = MCosy::GetFileName("tpoint/tpoint_%s.txt");
     1567        const TString name = MCosy::GetFileName("tpoint", "tpoint", "txt");
    15641568        cout << "TPoint-Starg File ********* " << name << " ********** " << endl;
    15651569
     
    17151719    // Find Star at Center---for Tpoint Procedure
    17161720    if (fDisplay->IsEntryChecked(IDM_kFindStar))
    1717         /*ZdAz zdaz =*/ FindStar(f, f2, center, t, 3.5, 70);
     1721        FindStar(f, f2, center, t, 3.5, 70);
    17181722
    17191723    byte zimg[kZOOM*kZOOM];
     
    17791783    {
    17801784
    1781         XY roquelamp(0,0);
    1782 
    17831785        Double_t imageclean = 1.5;
    17841786        Double_t boxradius = 60;
     
    17861788        XY searchcenter(768/2-1,576/2+25);
    17871789
    1788         roquelamp = FindRoqueLamp(f, f2, sgcenter, t, imageclean, boxradius, searchcenter);
     1790        XY roquelamp = FindRoqueLamp(f, f2, sgcenter, t, imageclean, boxradius, searchcenter);
    17891791
    17901792        if (fOutRq)
     
    18041806
    18051807    // Find Spot on Camera Center in Starguider camera
    1806 
    18071808    if (fOperations->IsEntryChecked(IDM_kRoqueLampAna))
    18081809    {
     
    18321833        f2.DrawCircle(sgcenter, 115.0, 0x0fa);
    18331834    }
    1834 
    18351835    // we calculate the offset given by the three ETH Leds visible to
    18361836    // the guide camera
     
    18841884
    18851885        // Position around which the circles are drawn.
    1886         const Ring skycenter(768/2+off.X(), 576/2+off.Y());
     1886        const Ring skycenter(768/2-off.X(), 576/2+off.Y());
    18871887
    18881888        // There are two corrections to the misspointing
     
    18961896            Leds spots;
    18971897            f.SetBox(230);
    1898 //          f.SetCut(1.5);
    1899             double bright;
     1898            f.SetCut(2.5);
     1899
     1900            double bright;
    19001901            f.ExecuteAndMark(spots, 530, 292, bright);
    1901             MString txt;
     1902
     1903            MString txt;
    19021904            txt.Print("Sky Brightness: %.1f", bright);
    19031905            fSkyBright->SetText(txt);
     
    19611963    {
    19621964        f2.DrawCircle(center, 0x0a);
    1963         f2.DrawCircle(center,   5.0,
     1965        f2.DrawCircle(center,   7.0,
    19641966                      fDisplay->IsEntryChecked(IDM_kFindStar)?3:0xb0);
    19651967        f2.DrawCircle(center, 115.0, 0x0a);
     
    20032005        if (aa.Az()<0)
    20042006            aa.Az(aa.Az()+360);
    2005         txt.Print("%.1fd/%.1fd (%d, %d)", -aa.Alt(), aa.Az()-180, fDx, fDy);
     2007        txt.Print("(%d, %d) %.1fd/%.1fd", fDx, fDy, -aa.Alt(), aa.Az()-180);
    20062008    }
    20072009    else
  • trunk/MagicSoft/Cosy/tcpip/MDriveCom.cc

    r7764 r7788  
    118118}
    119119
     120bool MDriveCom::CommandPREPS(TString &str)
     121{
     122    str = str.Strip(TString::kBoth);
     123    if (str.IsNull())
     124    {
     125        cout << "ERROR - No identifier for preposition (PREPS) given." << endl;
     126        return false;
     127    }
     128    if (str.First(' ')>=0)
     129    {
     130        cout << "ERROR - PREPS command syntax error (contains whitespaces)." << endl;
     131        return false;
     132    }
     133
     134    str.ToLower();
     135
     136    cout << "CC-COMMAND " << MTime(-1) << " PREPS '" << str << "'" << endl;
     137
     138    //cout << "MDriveCom - TRACK... start." << endl;
     139    fQueue->PostMsg(WM_PREPS, (void*)str.Data(), str.Length()+1);
     140    //cout << "MDriveCom - TRACK... done." << endl;
     141    return true;
     142}
     143
     144bool MDriveCom::CommandARM(TString &str)
     145{
     146    str = str.Strip(TString::kBoth);
     147    if (str.IsNull())
     148    {
     149        cout << "ERROR - No identifier for ARM command." << endl;
     150        return false;
     151    }
     152    if (str.First(' ')>=0)
     153    {
     154        cout << "ERROR - ARM command syntax error (contains whitespaces)." << endl;
     155        return false;
     156    }
     157
     158    str.ToLower();
     159    if (str!="lock" && str!="unlock")
     160    {
     161        cout << "ERROR - ARM command syntax error (neither LOCK nor UNLOCK)." << endl;
     162        return false;
     163    }
     164
     165    cout << "CC-COMMAND " << MTime(-1) << " ARM '" << str << "'" << endl;
     166
     167    bool lock = str=="lock";
     168
     169    fQueue->PostMsg(WM_ARM, &lock, sizeof(lock));
     170    return true;
     171}
     172
    120173bool MDriveCom::InterpreteCmd(TString cmd, TString str)
    121174{
     
    148201
    149202    if (cmd==(TString)"PREPS")
    150     {
    151         cout << "Prepos: " << str << endl;
    152         return true;
    153     }
     203        return CommandPREPS(str);
    154204
    155205    if (cmd.IsNull() && str.IsNull())
  • trunk/MagicSoft/Cosy/tcpip/MDriveCom.h

    r7764 r7788  
    2525    bool CommandGRB(TString &str);
    2626    bool CommandZDAZ(TString &str);
     27    bool CommandPREPS(TString &str);
     28    bool CommandARM(TString &str);
    2729
    2830public:
     
    4648
    4749#endif
    48 
    49 
    50 
    51 
    52 
    53 
    54 
    55 
    56 
    57 
    58 
  • trunk/MagicSoft/Cosy/videodev/FilterLed.cc

    r7230 r7788  
    125125                                     float &my, unsigned int &sum) const
    126126{
     127    //-------------------------------
     128    // Improved algorithm:
     129    // 1. Look for the largest five-pixel-cross signal inside the box
     130    int x0 = TMath::Max(x-box+1,   0);
     131    int y0 = TMath::Max(y-box+1,   0);
     132
     133    int x1 = TMath::Min(x+box+1-1, fW);
     134    int y1 = TMath::Min(y+box+1-1, fH);
     135
     136    int maxx=0;
     137    int maxy=0;
     138
     139    unsigned int max =0;
     140    for (int dx=x0; dx<x1; dx++)
     141    {
     142        for (int dy=y0; dy<y1; dy++)
     143        {
     144            const unsigned int sumloc =
     145                fImg[(dy+0)*fW + (dx-1)] +
     146                fImg[(dy+0)*fW + (dx+1)] +
     147                fImg[(dy+1)*fW + dx] +
     148                fImg[(dy+0)*fW + dx] +
     149                fImg[(dy-1)*fW + dx];
     150
     151            if(sumloc<=max)
     152                continue;
     153
     154            maxx=dx;
     155            maxy=dy;
     156            max =sum;
     157        }
     158    }
     159
     160    // 2. Calculate mean position inside a circle around
     161    // the highst cross-signal with radius of 6 pixels.
    127162    unsigned int sumx=0;
    128163    unsigned int sumy=0;
    129164
    130     //-------------------------------
    131     // Improved algorithm:
    132     // 1. Look for the largest four-pixel signal inside box
    133 
    134     int thissum=0, maxsum=0;
    135     int maxx=0, maxy=0;
    136     for (int dx=x-box; dx<x+box+1; dx++)
    137         for (int dy=y-box; dy<y+box+1; dy++)
    138         {
    139             thissum = fImg[dy*fW+dx]+fImg[(dy+1)*fW+dx]+
    140               fImg[dy*fW+(dx+1)]+fImg[(dy+1)*fW+(dx+1)];
    141             if(thissum>maxsum)
    142               {
    143                 maxx=dx;
    144                 maxy=dy;
    145                 maxsum=thissum;
    146               }
    147         }
    148 
    149     // 2. Calculate mean position inside a circle around
    150     // the highst four-pixel signal with radius of 5 pixels.
     165    const int rad = 17;
     166
     167    x0 = TMath::Max(x-box,   maxx-rad);
     168    y0 = TMath::Max(y-box,   maxy-rad);
     169
     170    x1 = TMath::Min(x+box+1, maxx+rad+1);
     171    y1 = TMath::Min(y+box+1, maxy+rad+1);
    151172
    152173    sum=0;
    153     for (int dx=x-box; dx<x+box+1; dx++)
    154         for (int dy=y-box; dy<y+box+1; dy++)
     174    for (int dx=x0; dx<x1; dx++)
     175        for (int dy=y0; dy<y1; dy++)
    155176        {
    156177            const byte &m = fImg[dy*fW+dx];
    157178
    158             // Circle
    159             if(sqrt((dx-maxx)*(dx-maxx)+
    160                     (dy-maxy)*(dy-maxy)) <= 6)
    161               {
    162                 sumx += m*dx;
    163                 sumy += m*dy;
    164                 sum  += m;
    165               }
     179            sumx += m*dx;
     180            sumy += m*dy;
     181            sum  += m;
    166182        }
    167183
     
    171187    return (int)my*fW + (int)mx;
    172188}
    173 
    174 
    175189
    176190int FilterLed::GetMeanPositionCircle(const int x, const int y,
     
    323337void FilterLed::Execute(Leds &leds, int xc, int yc, double &bright) const
    324338{
    325     int x0 = xc-fBox;
    326     int x1 = xc+fBox;
    327     int y0 = yc-fBox;
    328     int y1 = yc+fBox;
    329 
    330     if (x0<0) x0=0;
    331     if (y0<0) y0=0;
    332     if (x1>fW) x1=fW;
    333     if (y1>fH) y1=fH;
     339    const int x0 = TMath::Max(xc-fBox, 0);
     340    const int y0 = TMath::Max(yc-fBox, 0);
     341    const int x1 = TMath::Min(xc+fBox, fW);
     342    const int y1 = TMath::Min(yc+fBox, fH);
    334343
    335344    const int wx = x1-x0;
     
    430439
    431440    RemoveTwinsInterpol(leds, first, 5);
    432    
    433    
    434 }
    435 
    436 void FilterLed::FindStar(Leds &leds, int xc, int yc) const
     441}
     442
     443void FilterLed::FindStar(Leds &leds, int xc, int yc, bool circle) const
    437444{
    438445    // fBox: radius of the inner (signal) box
     
    442449    // Define inner box in which to search the signal
    443450    //
    444     int x0 = xc-fBox;
    445     int x1 = xc+fBox;
    446     int y0 = yc-fBox;
    447     int y1 = yc+fBox;
    448 
    449     if (x0<0) x0=0;
    450     if (y0<0) y0=0;
    451     if (x1>fW) x1=fW;
    452     if (y1>fH) y1=fH;
     451    const int x0 = TMath::Max(xc-fBox, 0);
     452    const int y0 = TMath::Max(yc-fBox, 0);
     453    const int x1 = TMath::Min(xc+fBox, fW);
     454    const int y1 = TMath::Min(yc+fBox, fH);
    453455
    454456    //
     
    459461    const double sqrt2 = sqrt(2.);
    460462
    461     int xa = xc-(int)rint(fBox*sqrt2);
    462     int xb = xc+(int)rint(fBox*sqrt2);
    463     int ya = yc-(int)rint(fBox*sqrt2);
    464     int yb = yc+(int)rint(fBox*sqrt2);
    465 
    466     if (xa<0) xa=0;
    467     if (ya<0) ya=0;
    468     if (xb>fW) xb=fW;
    469     if (yb>fH) yb=fH;
     463    const int xa = TMath::Max(xc-(int)rint(fBox*sqrt2), 0);
     464    const int ya = TMath::Max(yc-(int)rint(fBox*sqrt2), 0);
     465    const int xb = TMath::Min(xc+(int)rint(fBox*sqrt2), fW);
     466    const int yb = TMath::Min(yc+(int)rint(fBox*sqrt2), fH);
    470467
    471468    //
     
    538535    float mx, my;
    539536    unsigned int mag;
    540     int pos = GetMeanPosition(xc, yc, fBox-1, mx, my, mag);
    541 
    542     if (pos<0 || pos>=fW*fH && fImg[pos]<sum+fCut*sdev)
     537    int pos = circle ? GetMeanPositionCircle(xc, yc, fBox-1, mx, my, mag) : GetMeanPosition(xc, yc, fBox-1, mx, my, mag);
     538
     539    if (pos<0 || pos>=fW*fH || fImg[pos]<sum+fCut*sdev)
    543540        return;
    544541
     
    549546}
    550547
    551 void FilterLed::FindStarCircle(Leds &leds, int xc, int yc) const
    552 {
    553     // fBox: radius of the inner (signal) box
    554     // Radius of the outer box is fBox*sqrt(2)
    555 
    556     //
    557     // Define inner box in which to search the signal
    558     //
    559     int x0 = xc-fBox;
    560     int x1 = xc+fBox;
    561     int y0 = yc-fBox;
    562     int y1 = yc+fBox;
    563 
    564     if (x0<0) x0=0;
    565     if (y0<0) y0=0;
    566     if (x1>fW) x1=fW;
    567     if (y1>fH) y1=fH;
    568 
    569     //
    570     // Define outer box (excluding inner box) having almost
    571     // the same number of pixels in which the background
    572     // is calculated
    573     //
    574     const double sqrt2 = sqrt(2.);
    575 
    576     int xa = xc-(int)rint(fBox*sqrt2);
    577     int xb = xc+(int)rint(fBox*sqrt2);
    578     int ya = yc-(int)rint(fBox*sqrt2);
    579     int yb = yc+(int)rint(fBox*sqrt2);
    580 
    581     if (xa<0) xa=0;
    582     if (ya<0) ya=0;
    583     if (xb>fW) xb=fW;
    584     if (yb>fH) yb=fH;
    585 
    586     //
    587     // Calculate average and sdev for a square
    588     // excluding the inner part were we expect
    589     // the signal to be.
    590     //
    591     double sum = 0;
    592     double sq  = 0;
    593 
    594     int n=0;
    595     for (int x=xa; x<xb; x++)
    596         for (int y=ya; y<yb; y++)
    597         {
    598             if (x>=x0 && x<x1 && y>=y0 && y<y1)
    599                 continue;
    600 
    601             byte &b = fImg[y*fW+x];
    602 
    603             sum += b;
    604             sq  += b*b;
    605             n++;
    606         }
    607 
    608     sum /= n;
    609     sq  /= n;
    610 
    611     // 254 because b<=max and not b<max
    612     const double sdev = sqrt(sq-sum*sum);
    613     const byte   max  = sum+fCut*sdev>254 ? 254 : (byte)(sum+fCut*sdev);
    614 
    615     //
    616     // clean image from noise
    617     // (FIXME: A lookup table could accelerate things...
    618     //
    619     n=0;
    620     for (int x=x0; x<x1; x++)
    621         for (int y=y0; y<y1; y++)
    622         {
    623             byte &b = fImg[y*fW+x];
    624             if (b<=max)
    625                 b = 0;
    626             else
    627                 n++;
    628         }
    629 
    630     //
    631     // Mark the background region
    632     //
    633     for (int x=xa; x<xb; x+=2)
    634     {
    635         fImg[ya*fW+x]=0xf0;
    636         fImg[yb*fW+x]=0xf0;
    637     }
    638     for (int y=ya; y<yb; y+=2)
    639     {
    640         fImg[y*fW+xa]=0xf0;
    641         fImg[y*fW+xb]=0xf0;
    642     }
    643 
    644     //
    645     // Check if any pixel found...
    646     //
    647     if (n<5)
    648         return;
    649 
    650     //
    651     // Get the mean position of the star
    652     //
    653     float mx, my;
    654     unsigned int mag;
    655 
    656     //    int pos = GetMeanPosition(xc, yc, fBox-1, mx, my, mag);
    657 
    658     // try new method
    659     int pos = GetMeanPositionCircle(xc, yc, fBox-1, mx, my, mag);
    660    
    661     if (pos<0 || pos>=fW*fH && fImg[pos]<sum+fCut*sdev)
    662         return;
    663 
    664     cout << "Mean=" << sum << "  SDev=" << sdev << "  :  ";
    665     cout << "Sum/n = " << sum << "/" << n << " = " << (n==0?0:mag/n) << endl;
    666 
    667     leds.Add(mx, my, 0, 0, -2.5*log10((float)mag)+13.7);
    668 }
    669 
    670 
    671548void FilterLed::Stretch() const
    672549{
     
    698575    }
    699576}
    700 
  • trunk/MagicSoft/Cosy/videodev/FilterLed.h

    r7230 r7788  
    4949    void SetBox(int box)   { fBox = box; }
    5050    void SetCut(float cut) { fCut = cut; }
    51     void FindStar(Leds &leds, int xc, int yc) const;
    52     void FindStarCircle(Leds &leds, int xc, int yc) const;
     51    void FindStar(Leds &leds, int xc, int yc, bool circle=false) const;
    5352   
    5453    void Execute(Leds &leds, int xc, int yc, double &bright) const;
Note: See TracChangeset for help on using the changeset viewer.