source: trunk/MagicSoft/Cosy/gui/MGStarguider.cc@ 1804

Last change on this file since 1804 was 1804, checked in by tbretz, 22 years ago
*** empty log message ***
  • Property svn:executable set to *
File size: 17.4 KB
Line 
1#include "MGStarguider.h"
2
3#include <fstream.h> // ifstream
4#include <iostream.h> // cout
5
6#include <TTimer.h>
7
8#include <TGMenu.h>
9#include <TSystem.h>
10#include <TGSplitter.h> // TGHorizontal3DLine
11#include <TGTextEntry.h>
12
13#include "MGImage.h"
14#include "MGCoordinates.h"
15
16#include "coord.h"
17
18#include "StarCatalog.h"
19
20#include "Filter.h"
21#include "Filter2.h"
22#include "Writer.h"
23#include "base/timer.h"
24
25#include "MStarList.h"
26
27ClassImp(MGStarguider);
28
29enum {
30 IDM_kFilter,
31 IDM_kCatalog,
32 IDM_kStarguider,
33 IDM_kStart,
34 IDM_kStop,
35 IDM_kFileType,
36 IDM_kPPM,
37 IDM_kPNG,
38 IDM_kOnce,
39 IDM_kUseFileRaDec,
40 IDM_kContinous,
41 IDM_kRate25ps,
42 IDM_kRate5ps,
43 IDM_kRate1s,
44 IDM_kRate5s,
45 IDM_kRate30s,
46 IDM_kRate1m,
47 IDM_kRate5m,
48 IDM_kSetup,
49 IDM_kLimMag3,
50 IDM_kLimMag4,
51 IDM_kLimMag5,
52 IDM_kLimMag6,
53 IDM_kLimMag7,
54 IDM_kLimMag8,
55 IDM_kLimMag9,
56 IDM_kPixSize,
57 IDM_kInterpol125,
58 IDM_kInterpol25,
59 IDM_kInterpol10,
60 IDM_kInterpol5,
61 IDM_kInterpol2,
62 IDM_kInterpol1
63};
64
65Bool_t MGStarguider::HandleTimer(TTimer *t)
66{
67 fImage->DoRedraw();
68 fZoomImage->DoRedraw();
69 return kTRUE;
70}
71
72#define kZOOM 96
73
74MGStarguider::MGStarguider(MObservatory::LocationName_t key)
75: TGMainFrame(gClient->GetRoot(), 768, 700), fObservatory(key), fDx((768-kZOOM)/2), fDy((512-kZOOM)/2)
76{
77 gVirtualX->GrabButton(fId, kButton2, 0, 0, 0, 0, kTRUE);
78
79 fList = new MGList;
80
81 fSao = new StarCatalog(fObservatory);
82 fRaDec = new RaDec(180, 40);
83
84 // p = pointer to MainFrame (not owner)
85
86 const TGWindow *p=gClient->GetRoot();
87
88 //
89 // Create Menu for MGStarguider Display
90 //
91 fDisplay = new TGPopupMenu(p);
92 fDisplay->AddEntry("&Filter", IDM_kFilter);
93 fDisplay->AddEntry("Sao &Catalog", IDM_kCatalog);
94 fDisplay->AddEntry("Starguider", IDM_kStarguider);
95 fDisplay->Associate(this);
96 fList->Add(fDisplay);
97
98 fFileType = new TGPopupMenu(p);
99 fFileType->AddEntry("PP&M", IDM_kPPM);
100 fFileType->AddEntry("&PNG", IDM_kPNG);
101 fFileType->CheckEntry(IDM_kPNG);
102 fFileType->Associate(this);
103 fList->Add(fFileType);
104
105 fWriteType = new TGPopupMenu(p);
106 fWriteType->AddEntry("Once", IDM_kOnce);
107 fWriteType->AddEntry("Continous", IDM_kContinous);
108 fWriteType->CheckEntry(IDM_kOnce);
109 fWriteType->Associate(this);
110 fList->Add(fWriteType);
111
112 fWriteRate = new TGPopupMenu(p);
113 fWriteRate->AddEntry("25/s", IDM_kRate25ps);
114 fWriteRate->AddEntry("5/s", IDM_kRate5ps);
115 fWriteRate->AddEntry("1s", IDM_kRate1s);
116 fWriteRate->AddEntry("5s", IDM_kRate5s);
117 fWriteRate->AddEntry("30s", IDM_kRate30s);
118 fWriteRate->AddEntry("1min", IDM_kRate1m);
119 fWriteRate->AddEntry("5min", IDM_kRate5m);
120 fWriteRate->CheckEntry(IDM_kRate1m);
121 fWriteRate->Associate(this);
122 fList->Add(fWriteRate);
123
124 fWrtRate = 25*60;
125
126 fWrite = new TGPopupMenu(p);
127 fWrite->AddEntry("&Start", IDM_kStart);
128 fWrite->AddEntry("Sto&p", IDM_kStop);
129 fWrite->AddSeparator();
130 fWrite->AddPopup("File &Type", fFileType);
131 fWrite->AddPopup("&Write Type", fWriteType);
132 fWrite->AddPopup("Write &Rate", fWriteRate);
133 fWrite->DisableEntry(IDM_kStop);
134 fWrite->Associate(this);
135 fList->Add(fWrite);
136
137 fLimMag = new TGPopupMenu(p);
138 fLimMag->AddEntry("3", IDM_kLimMag3);
139 fLimMag->AddEntry("4", IDM_kLimMag4);
140 fLimMag->AddEntry("5", IDM_kLimMag5);
141 fLimMag->AddEntry("6", IDM_kLimMag6);
142 fLimMag->AddEntry("7", IDM_kLimMag7);
143 fLimMag->AddEntry("8", IDM_kLimMag8);
144 fLimMag->AddEntry("9", IDM_kLimMag9);
145 fLimMag->CheckEntry(IDM_kLimMag8);
146 fLimMag->Associate(this);
147 fList->Add(fLimMag);
148
149 fSao->SetLimitMag(8.0);
150
151 fInterpol = new TGPopupMenu(p);
152 fInterpol->AddEntry("125", IDM_kInterpol125);
153 fInterpol->AddEntry("25", IDM_kInterpol25);
154 fInterpol->AddEntry("10", IDM_kInterpol10);
155 fInterpol->AddEntry("5", IDM_kInterpol5);
156 fInterpol->AddEntry("2", IDM_kInterpol2);
157 fInterpol->AddEntry("Off", IDM_kInterpol1);
158 fInterpol->CheckEntry(IDM_kInterpol25);
159 fInterpol->Associate(this);
160 fList->Add(fInterpol);
161
162 fIntRate = 25;
163
164 fSetup = new TGPopupMenu(p);
165 fSetup->AddPopup("Lim. &Magnitude", fLimMag);
166 fSetup->AddPopup("Disp. &Interpolation", fInterpol);
167 fSetup->AddEntry("Use Ra/Dec from file", IDM_kUseFileRaDec);
168 fSetup->Associate(this);
169 fList->Add(fSetup);
170
171 fMenu = new TGMenuBar(this, 0, 0, kHorizontalFrame);
172 fMenu->AddPopup("&Display", fDisplay, NULL);
173 fMenu->AddPopup("&Write", fWrite, NULL);
174 fMenu->AddPopup("&Setup", fSetup, NULL);
175 fMenu->Resize(fMenu->GetDefaultSize());
176 AddFrame(fMenu); //, new TGLayoutHints (kLHintsNormal, 0, 4, 0, 0));
177 fList->Add(fMenu);
178
179 fCRaDec = new MGCoordinates(this, kETypeRaDec);
180 fCRaDec->Move(1, fMenu->GetDefaultHeight()+584);
181 AddFrame(fCRaDec);
182 fList->Add(fCRaDec);
183
184 fCZdAz = new MGCoordinates(this, kETypeZdAz);
185 fCZdAz->Move(240+12+10, fMenu->GetDefaultHeight()+584);
186 AddFrame(fCZdAz);
187 fList->Add(fCZdAz);
188
189 const Double_t pixsize = 23.5;
190
191 fSao->SetPixSize(pixsize/3600);
192
193 TString txt;
194 txt += pixsize;
195
196 fPixSize = new TGTextEntry(this, txt, IDM_kPixSize);
197 fPixSize->SetAlignment(kTextCenterX);
198 fPixSize->Move(600, fMenu->GetDefaultHeight()+584);
199 AddFrame(fPixSize);
200 fList->Add(fPixSize);
201
202 // TGHorizontal3DLine *fLineSep = new TGHorizontal3DLine(this);
203 // AddFrame(fLineSep, new TGLayoutHints (kLHintsNormal | kLHintsExpandX));
204 // fList->Add(fLineSep);
205
206 //
207 // Create Image Display
208 //
209 fZoomImage = new MGImage(this, kZOOM, kZOOM);
210 fZoomImage->Move(768-kZOOM-2, 700-kZOOM-2);
211 AddFrame(fZoomImage);
212 fList->Add(fZoomImage);
213
214 fImage = new MGImage(this, 768, 576);
215 fImage->Move(0, fMenu->GetDefaultHeight());
216 AddFrame(fImage);
217 fList->Add(fImage);
218
219 //
220 // Make everything visible
221 //
222 SetWindowName("MGStarguider Main Window");
223 SetIconName("MGStarguider");
224
225 MapSubwindows();
226 MapWindow();
227
228 fTimer=new TTimer(this, 100); // 100ms
229 fTimer->TurnOn();
230}
231
232MGStarguider::~MGStarguider()
233{
234 gVirtualX->GrabButton(0, kButton2, 0, 0, 0, 0, kFALSE);
235
236 fTimer->TurnOff();
237 delete fTimer;
238
239 delete fSao;
240 delete fRaDec;
241
242 delete fList;
243 cout << "Camera Display destroyed." << endl;
244}
245
246void MGStarguider::Layout()
247{
248 // Resize(GetDefaultSize());
249}
250
251void MGStarguider::CloseWindow()
252{
253 cout << "EventDisplay::CloseWindow: Exit Application Loop." << endl;
254
255 /*ExitLoop();*/
256 //cout << "FIXME: ExitLoop not called!!!!!!" << endl;
257
258 gSystem->ExitLoop();
259}
260
261void MGStarguider::Toggle(TGPopupMenu *p, UInt_t id)
262{
263 if (p->IsEntryChecked(id))
264 p->UnCheckEntry(id);
265 else
266 p->CheckEntry(id);
267
268}
269
270Bool_t MGStarguider::ProcessMessage(Long_t msg, Long_t mp1, Long_t mp2)
271{
272 switch (GET_MSG(msg))
273 {
274 case kC_TEXTENTRY:
275 if (GET_SUBMSG(msg)==kTE_ENTER)
276 {
277 const Float_t pixsize = atof(fPixSize->GetText());
278 cout << "Pixel Size changed to " << pixsize << "\"/pix" << endl;
279 fSao->SetPixSize(pixsize/3600);
280 }
281 return kTRUE;
282
283 case kC_COMMAND:
284 switch (GET_SUBMSG(msg))
285 {
286 case kCM_MENU:
287 switch (mp1)
288 {
289 case IDM_kCatalog:
290 Toggle(fDisplay, IDM_kCatalog);
291 if (fDisplay->IsEntryChecked(IDM_kCatalog))
292 fDisplay->EnableEntry(IDM_kStarguider);
293 else
294 {
295 fDisplay->UnCheckEntry(IDM_kStarguider);
296 fDisplay->DisableEntry(IDM_kStarguider);
297 }
298 return kTRUE;
299
300 case IDM_kStarguider:
301 Toggle(fDisplay, IDM_kStarguider);
302 return kTRUE;
303
304 case IDM_kFilter:
305 Toggle(fDisplay, IDM_kFilter);
306 if (fDisplay->IsEntryChecked(IDM_kFilter))
307 fDisplay->EnableEntry(IDM_kStarguider);
308 else
309 {
310 fDisplay->UnCheckEntry(IDM_kStarguider);
311 fDisplay->DisableEntry(IDM_kStarguider);
312 }
313 return kTRUE;
314
315 case IDM_kUseFileRaDec:
316 Toggle(fSetup, IDM_kUseFileRaDec);
317 return kTRUE;
318
319 case IDM_kStart:
320 fWrite->DisableEntry(IDM_kStart);
321 fWrite->EnableEntry(IDM_kStop);
322 return kTRUE;
323
324 case IDM_kStop:
325 fWrite->DisableEntry(IDM_kStop);
326 fWrite->EnableEntry(IDM_kStart);
327 return kTRUE;
328
329 case IDM_kPNG:
330 fFileType->CheckEntry(IDM_kPNG);
331 fFileType->UnCheckEntry(IDM_kPPM);
332 return kTRUE;
333
334 case IDM_kPPM:
335 fFileType->CheckEntry(IDM_kPPM);
336 fFileType->UnCheckEntry(IDM_kPNG);
337 return kTRUE;
338
339 case IDM_kOnce:
340 fWriteType->CheckEntry(IDM_kOnce);
341 fWriteType->UnCheckEntry(IDM_kContinous);
342 return kTRUE;
343
344 case IDM_kContinous:
345 fWriteType->CheckEntry(IDM_kContinous);
346 fWriteType->UnCheckEntry(IDM_kOnce);
347 return kTRUE;
348
349 case IDM_kRate25ps:
350 case IDM_kRate5ps:
351 case IDM_kRate1s:
352 case IDM_kRate5s:
353 case IDM_kRate30s:
354 case IDM_kRate1m:
355 case IDM_kRate5m:
356 for (int i=IDM_kRate25ps; i<=IDM_kRate5m; i++)
357 if (mp1==i)
358 fWriteRate->CheckEntry(i);
359 else
360 fWriteRate->UnCheckEntry(i);
361 switch (mp1)
362 {
363 case IDM_kRate25ps:
364 fWrtRate = 1;
365 return kTRUE;
366 case IDM_kRate5ps:
367 fWrtRate = 5;
368 return kTRUE;
369 case IDM_kRate1s:
370 fWrtRate = 25;
371 return kTRUE;
372 case IDM_kRate5s:
373 fWrtRate = 5*25;
374 return kTRUE;
375 case IDM_kRate30s:
376 fWrtRate = 30*25;
377 return kTRUE;
378 case IDM_kRate1m:
379 fWrtRate = 60*25;
380 return kTRUE;
381 case IDM_kRate5m:
382 fWrtRate = 5*60*25;
383 return kTRUE;
384 }
385 return kTRUE;
386
387 case IDM_kInterpol125:
388 case IDM_kInterpol25:
389 case IDM_kInterpol10:
390 case IDM_kInterpol5:
391 case IDM_kInterpol2:
392 case IDM_kInterpol1:
393 for (int i=IDM_kInterpol125; i<=IDM_kInterpol1; i++)
394 if (mp1==i)
395 fInterpol->CheckEntry(i);
396 else
397 fInterpol->UnCheckEntry(i);
398 switch (mp1)
399 {
400 case IDM_kInterpol1:
401 fIntRate = 1;
402 return kTRUE;
403 case IDM_kInterpol2:
404 fIntRate = 2;
405 return kTRUE;
406 case IDM_kInterpol5:
407 fIntRate = 5;
408 return kTRUE;
409 case IDM_kInterpol10:
410 fIntRate = 10;
411 return kTRUE;
412 case IDM_kInterpol25:
413 fIntRate = 25;
414 return kTRUE;
415 case IDM_kInterpol125:
416 fIntRate = 125;
417 return kTRUE;
418 }
419 return kTRUE;
420
421 case IDM_kLimMag3:
422 case IDM_kLimMag4:
423 case IDM_kLimMag5:
424 case IDM_kLimMag6:
425 case IDM_kLimMag7:
426 case IDM_kLimMag8:
427 case IDM_kLimMag9:
428 for (int i=IDM_kLimMag3; i<=IDM_kLimMag9; i++)
429 if (mp1==i)
430 fLimMag->CheckEntry(i);
431 else
432 fLimMag->UnCheckEntry(i);
433
434 fSao->SetLimitMag(mp1-IDM_kLimMag3+3);
435 return kTRUE;
436 }
437 break;
438 }
439 break;
440 }
441
442 return kTRUE;
443}
444
445void MGStarguider::GetCoordinates()
446{
447 XY xy = fCRaDec->GetCoordinates();
448
449 if (fSetup->IsEntryChecked(IDM_kUseFileRaDec))
450 {
451 ifstream fin("coordinates.txt");
452 if (!fin)
453 cout << "Error: Cannot open 'coordinates.txt' using fall back solution." << endl;
454 else
455 fin >> xy;
456 }
457
458 fCRaDec->SetCoordinates(xy);
459 fRaDec->Set(xy.X()*360/24, xy.Y());
460}
461
462void MGStarguider::CalcTrackingError(MStarList &spots, MStarList &stars)
463{
464 if (stars.GetRealEntries() < 3)
465 {
466 cout << "Sorry, less than 3 stars in FOV!" << endl;
467 return;
468 }
469
470 if (spots.GetRealEntries() < 1)
471 {
472 cout << "Sorry, less than 1 detected spot in FOV!" << endl;
473 return;
474 }
475
476 Int_t idx = 0;
477
478 MStarList sortedspots;
479
480 MStar *star;
481 MStar *spot;
482 MStarListIter NextStar(&stars);
483 MStarListIter NextSpot(&spots);
484
485 while ((spot=NextSpot()))
486 {
487 AltAz aa = fSao->CalcAltAzFromPix(spot->GetX(), spot->GetY());
488 spot->Set(aa.Az(), aa.Alt());
489 }
490
491 while ((star=NextStar()))
492 {
493 AltAz aa = fSao->CalcAltAzFromPix(star->GetX(), star->GetY());
494 star->Set(aa.Az(), aa.Alt());
495
496 const double aaz = star->GetX();
497 const double dphi2 = aaz/2.;
498 const double cos2 = cos(dphi2)*cos(dphi2);
499 const double sin2 = sin(dphi2)*sin(dphi2);
500
501 Double_t min = 800;
502
503 NextSpot.Reset();
504 while ((spot=NextSpot()))
505 {
506 const double pzd = TMath::Pi()/2-spot->GetY();
507 const double azd = TMath::Pi()/2-star->GetY();
508
509 const double d = cos(azd)*cos2 - cos(2*pzd+azd)*sin2;
510
511 const Double_t dist = acos(d);
512
513 if (dist>=min)
514 continue;
515
516 min = dist;
517 sortedspots.AddAt(idx, spot->GetX(), spot->GetY(), spot->GetMag());
518 }
519 if (min>768)
520 {
521 cout << "ERROR!!!!!!!!" << endl;
522 return;
523 }
524 idx++;
525 }
526
527 //
528 // Now we have in sortedspots the entries with the shortest distances
529 // to the corresponding ones in stars.
530 // Now calculate the tracking error.
531 //
532 NextStar.Reset();
533 MStarListIter NextSpot2(&sortedspots);
534
535 Double_t meanx=0;
536 Double_t meany=0;
537
538 while ((star=NextStar()))
539 {
540 spot = NextSpot2();
541
542 meanx += star->GetX() - spot->GetX();
543 meany += star->GetY() - spot->GetY();
544 }
545
546 meanx /= idx;
547 meany /= idx;
548
549 cout << "Tracking Error: dAlt=" << meany*180/TMath::Pi();
550 cout << "° dAz=" << meanx*180/TMath::Pi() << "° (calculated";
551 cout << " with " << idx << " stars/spots)" << endl;
552}
553
554void MGStarguider::ProcessFrame(const unsigned long n, byte *img, struct timeval *tm)
555{
556 static float myimg[768*576];
557
558 for (int i=0; i<768*576; i++)
559 myimg[i] += img[i];
560
561 if (n%fIntRate)
562 return;
563
564 cout << "Img: " << n << endl;
565
566 byte c[768*576];
567 for (int i=0; i<768*576; i++)
568 c[i] = (byte)(myimg[i]/fIntRate+.5);
569
570 if (!fWrite->IsEntryEnabled(IDM_kStart) &&
571 (!(n%fWrtRate) || fWriteType->IsEntryChecked(IDM_kOnce)))
572 {
573 if (fFileType->IsEntryChecked(IDM_kPNG))
574 {
575 static int num = 0;
576 char name[80];
577 sprintf(name, "pix/file%04d.png", num++);
578 Writer::Png(name, c, tm);
579 }
580
581 if (fFileType->IsEntryChecked(IDM_kPPM))
582 {
583 static int num = 0;
584 char name[80];
585 sprintf(name, "pix/file%04d.ppm", num++);
586 Writer::Ppm(name, c);
587 }
588
589 if (fWriteType->IsEntryChecked(IDM_kOnce))
590 ProcessMessage(MK_MSG(kC_COMMAND, kCM_MENU), IDM_kStop, 0);
591 }
592
593
594 MStarList spots;
595 if (fDisplay->IsEntryChecked(IDM_kStarguider))
596 Filter2::Execute(spots, c);
597 else
598 if (fDisplay->IsEntryChecked(IDM_kFilter))
599 Filter::Execute(c);
600
601 byte zimg[kZOOM*kZOOM];
602 for (int y=0; y<kZOOM; y++)
603 for (int x=0; x<kZOOM; x++)
604 zimg[x+y*kZOOM] = c[(fDx+(x-kZOOM/2)/2)+(fDy+(y-kZOOM/2)/2)*768];
605
606 fZoomImage->DrawImg(zimg);
607
608 if (fDisplay->IsEntryChecked(IDM_kCatalog))
609 {
610 byte cimg[768*576];
611
612 GetCoordinates();
613
614 Timer time(tm);
615
616 MStarList stars;
617 fSao->GetStars(stars, time.GetMjd(), *fRaDec);
618 fSao->GetImg(c, cimg, stars);
619 //fSao->GetImg(c, cimg, time.CalcMjd(), *fRaDec);
620
621 fImage->DrawColImg(c, cimg);
622
623 fCZdAz->SetCoordinates(fSao->GetZdAz());
624
625 if (fDisplay->IsEntryChecked(IDM_kStarguider))
626 CalcTrackingError(spots, stars);
627 }
628 else
629 fImage->DrawImg(c);
630
631 memset(myimg, 0, 768*576*sizeof(float));
632}
633
634Bool_t MGStarguider::HandleDoubleClick(Event_t *event)
635{
636 const Int_t w = fImage->GetWidth();
637 const Int_t h = fImage->GetHeight();
638 const Int_t x = fImage->GetX();
639 const Int_t y = fImage->GetY();
640
641 if (!(event->fX>x && event->fX<x+w && event->fY>y && event->fY<y+h))
642 return kTRUE;
643
644 Int_t dx = event->fX-x;
645 Int_t dy = event->fY-y;
646
647 if (dx<kZOOM/4) dx=kZOOM/4;
648 if (dy<kZOOM/4) dy=kZOOM/4;
649 if (dx>766-kZOOM/2) dx=766-kZOOM/4;
650 if (dy>510-kZOOM/2) dy=510-kZOOM/4;
651
652 fDx = dx;
653 fDy = dy;
654
655 cout << "New coordinates for zoom: " << fDx << " " << fDy << endl;
656
657 return kTRUE;
658}
Note: See TracBrowser for help on using the repository browser.