Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

source: trunk/FACT++/drive/MStarguider.cc@ 18622

Visit:

Last change on this file since 18622 was 18618, checked in by tbretz, 9 years ago
Copied files from Mars and Cosy to compile toold which fit our current drivectrl.
File size: 62.6 KB

Line
1	#undef EXPERT
2	#define FACT
3
4	#include "MStarguider.h"
5
6	#include <fstream> // ifstream
7
8	#include <TH2F.h>
9	#include <TGraph.h>
10	#include <TTimer.h>
11	#include <TEnv.h>
12	#include <TSystem.h>
13	#include <TFile.h> // temp writeout of histos
14	//#include <TSocket.h>
15
16	#include <TGMenu.h>
17	#include <TGLabel.h>
18	#include <TGButton.h>
19	#include <TGSplitter.h> // TGHorizontal3DLine
20	#include <TGTextEntry.h>
21	#include <TGLayout.h>
22	#include "MString.h"
23
24	#include "MLog.h"
25	#include "MLogManip.h"
26
27	#include "MAstro.h"
28	#include "MString.h"
29
30
31	#include "MCosy.h"
32	#include "MCaos.h"
33	// #include "MStargLeds.h"
34	#include "MStargHistograms.h"
35	#include "MDriveCom.h"
36
37	#include "MGStarg.h"
38	#include "MGNumStars.h"
39
40	#include "MGImage.h"
41	#include "MGCoordinates.h"
42
43	#include "Camera.h"
44	#include "PngReader.h"
45
46	#include "Led.h"
47	#include "Writer.h"
48	#include "FilterLed.h"
49	#include "MStarList.h"
50	#include "CaosFilter.h"
51	#include "StarCatalog.h"
52	#include "MGeomCamMagic.h"
53	#include "MAstroCamera.h"
54
55	#include "MGCosy.h"
56
57	ClassImp(MStarguider);
58
59	using namespace std;
60
61	enum {
62	IDM_kFilter,
63	IDM_kFindStar,
64	IDM_kCaosFilter,
65	IDM_kCatalog,
66	IDM_kStarguider,
67	IDM_kStart,
68	IDM_kStop,
69	IDM_kFileType,
70	IDM_kPPM,
71	IDM_kPNG,
72	IDM_kOnce,
73	IDM_kStretch,
74	IDM_kInput,
75	IDM_kChannel1,
76	IDM_kChannel2,
77	IDM_kChannel3,
78	IDM_kContinous,
79	IDM_kRate25ps,
80	IDM_kRate5ps,
81	IDM_kRate1s,
82	IDM_kRate5s,
83	IDM_kRate30s,
84	IDM_kRate1m,
85	IDM_kRate5m,
86	IDM_kSetup,
87	IDM_kLimMag3,
88	IDM_kLimMag4,
89	IDM_kLimMag5,
90	IDM_kLimMag6,
91	IDM_kLimMag7,
92	IDM_kLimMag8,
93	IDM_kLimMag9,
94	IDM_kPixSize,
95	IDM_kAngle,
96	IDM_kCut,
97	IDM_kInterpol250,
98	IDM_kInterpol125,
99	IDM_kInterpol50,
100	IDM_kInterpol25,
101	IDM_kInterpol10,
102	IDM_kInterpol5,
103	IDM_kInterpol2,
104	IDM_kInterpol1,
105	IDM_kCaosPrintRings,
106	IDM_kCaosPrintLeds,
107	IDM_kCaosAnalStart,
108	IDM_kCaosAnalStop,
109	IDM_kCaosWriteStart,
110	IDM_kCaosWriteStop,
111	IDM_kResetHistograms,
112	IDM_kStargAnalysis,
113	IDM_kStargCaosFilter,
114	IDM_kStarguiderMode,
115	IDM_kTpointMode
116
117	};
118
119	Bool_t MStarguider::HandleTimer(TTimer *t)
120	{
121	if (IsMapped())
122	{
123	fImage->DoRedraw();
124	fZoomImage->DoRedraw();
125	}
126
127	if (fCosy && fCosy->GetWin()->IsMapped())
128	fCosy->GetWin()->GetImage()->DoRedraw();
129
130	fGStarg->Update(fPos, fD);
131	if (fDisplay->IsEntryChecked(IDM_kStarguider))
132	fGNumStars->Update(fNumStarsDetected, fNumStarsCorrelated);
133
134	return kTRUE;
135	}
136
137	#define kZOOM 96
138
139	XY MStarguider::GetCoordinates() const
140	{
141	return fPZdAz->GetCoordinates();
142	}
143
144	void MStarguider::InitGui(Int_t channel)
145	{
146	fList = new MGList;
147	fList->SetOwner();
148
149	const TGWindow *p=gClient->GetRoot();
150
151	fChannel = new TGPopupMenu(p);
152	fChannel->AddEntry("Starfield Camera", IDM_kChannel1);
153	fChannel->AddEntry("TPoint Camera", IDM_kChannel2);
154	fChannel->AddEntry("Read from File", IDM_kChannel3);
155	if (channel<0)
156	fChannel->CheckEntry(IDM_kChannel3);
157	else
158	fChannel->CheckEntry(channel==0?IDM_kChannel1:IDM_kChannel2);
159	fChannel->Associate(this);
160	fList->Add(fChannel);
161
162	fFileType = new TGPopupMenu(p);
163	fFileType->AddEntry("PP&M", IDM_kPPM);
164	fFileType->AddEntry("&PNG", IDM_kPNG);
165	fFileType->CheckEntry(IDM_kPNG);
166	fFileType->Associate(this);
167	fList->Add(fFileType);
168
169	fWriteType = new TGPopupMenu(p);
170	fWriteType->AddEntry("&Once", IDM_kOnce);
171	fWriteType->AddEntry("&Continous", IDM_kContinous);
172	fWriteType->CheckEntry(IDM_kOnce);
173	fWriteType->Associate(this);
174	fList->Add(fWriteType);
175
176	fWriteRate = new TGPopupMenu(p);
177	fWriteRate->AddEntry("25/s", IDM_kRate25ps);
178	fWriteRate->AddEntry("5/s", IDM_kRate5ps);
179	fWriteRate->AddEntry("1s", IDM_kRate1s);
180	fWriteRate->AddEntry("5s", IDM_kRate5s);
181	fWriteRate->AddEntry("30s", IDM_kRate30s);
182	fWriteRate->AddEntry("1min", IDM_kRate1m);
183	fWriteRate->AddEntry("5min", IDM_kRate5m);
184	fWriteRate->CheckEntry(IDM_kRate1m);
185	fWriteRate->Associate(this);
186	fList->Add(fWriteRate);
187
188	fWrtRate = 25*60;
189
190	fLimMag = new TGPopupMenu(p);
191	fLimMag->AddEntry("3", IDM_kLimMag3);
192	fLimMag->AddEntry("4", IDM_kLimMag4);
193	fLimMag->AddEntry("5", IDM_kLimMag5);
194	fLimMag->AddEntry("6", IDM_kLimMag6);
195	fLimMag->AddEntry("7", IDM_kLimMag7);
196	fLimMag->AddEntry("8", IDM_kLimMag8);
197	fLimMag->AddEntry("9", IDM_kLimMag9);
198	fLimMag->CheckEntry(IDM_kLimMag9);
199	fLimMag->Associate(this);
200	fList->Add(fLimMag);
201
202	fSao->SetLimitMag(9.0);
203
204	fInterpol = new TGPopupMenu(p);
205	fInterpol->AddEntry("250", IDM_kInterpol250);
206	fInterpol->AddEntry("125", IDM_kInterpol125);
207	fInterpol->AddEntry("50", IDM_kInterpol50);
208	fInterpol->AddEntry("25", IDM_kInterpol25);
209	fInterpol->AddEntry("10", IDM_kInterpol10);
210	fInterpol->AddEntry("5", IDM_kInterpol5);
211	fInterpol->AddEntry("2", IDM_kInterpol2);
212	fInterpol->AddEntry("Off", IDM_kInterpol1);
213	fInterpol->Associate(this);
214	fList->Add(fInterpol);
215
216	TString disp=gVirtualX->DisplayName();
217	gLog << all << "Display: " << disp << endl;
218	if (disp.First(':')>=0)
219	disp=disp(0, disp.First(':'));
220
221	if (disp.IsNull() \|\| disp==(TString)"localhost")
222	{
223	fInterpol->CheckEntry(IDM_kInterpol5);
224	fIntRate = 50;
225	}
226	else
227	{
228	fInterpol->CheckEntry(IDM_kInterpol125);
229	fIntRate = 125;
230	}
231
232	fCaosPrint = new TGPopupMenu(p);
233	fCaosPrint->AddEntry("&Leds", IDM_kCaosPrintLeds);
234	fCaosPrint->AddEntry("&Rings", IDM_kCaosPrintRings);
235	fCaosPrint->Associate(this);
236	fList->Add(fCaosPrint);
237
238	fCaosWrite = new TGPopupMenu(p);
239	fCaosWrite->AddEntry("&Start", IDM_kCaosWriteStart);
240	fCaosWrite->AddEntry("Sto&p", IDM_kCaosWriteStop);
241	fCaosWrite->DisableEntry(IDM_kCaosWriteStop);
242	fCaosWrite->Associate(this);
243	fList->Add(fCaosWrite);
244
245	fCaosAnalyse = new TGPopupMenu(p);
246	fCaosAnalyse->AddEntry("S&tart Analysis", IDM_kCaosAnalStart);
247	fCaosAnalyse->AddEntry("St&op Analysis", IDM_kCaosAnalStop);
248	fCaosAnalyse->DisableEntry(IDM_kCaosAnalStop);
249	fCaosAnalyse->Associate(this);
250	fList->Add(fCaosAnalyse);
251
252	fMenu = new TGMenuBar(this, 0, 0, kHorizontalFrame);
253	fDisplay = fMenu->AddPopup("&Display");
254	fMode = fMenu->AddPopup("&Mode");
255	fWritePictures = fMenu->AddPopup("&WritePics");
256	fSetup = fMenu->AddPopup("&Setup");
257	fOperations = fMenu->AddPopup("&Operations");
258	fMenu->Resize(fMenu->GetDefaultSize());
259	AddFrame(fMenu);
260
261	//
262	// Create Menu for MStarguider Display
263	//
264	//fDisplay = new MMGPopupMenu(p);
265	fDisplay->AddEntry("&Filter", IDM_kFilter);
266	fDisplay->AddEntry("Stretch", IDM_kStretch);
267	fDisplay->AddSeparator();
268	fDisplay->AddEntry("Find &Star", IDM_kFindStar);
269	fDisplay->AddEntry("C&aos Filter", IDM_kCaosFilter);
270	fDisplay->AddSeparator();
271	fDisplay->AddEntry("SAO &Catalog", IDM_kCatalog);
272	fDisplay->AddEntry("Starguider", IDM_kStarguider);
273	fDisplay->AddEntry("Starguider LED Filter", IDM_kStargCaosFilter);
274	fDisplay->AddSeparator();
275	if (channel>=0)
276	fDisplay->AddPopup("&Input", fChannel);
277	fDisplay->CheckEntry(IDM_kStretch);
278	fDisplay->Associate(this);
279
280	fMode->AddEntry("Starguider", IDM_kStarguiderMode);
281	fMode->AddEntry("Tpoint", IDM_kTpointMode);
282	fMode->Associate(this);
283
284	fWritePictures->AddEntry("&Start", IDM_kStart);
285	fWritePictures->AddEntry("Sto&p", IDM_kStop);
286	fWritePictures->AddSeparator();
287	fWritePictures->AddPopup("File &Type", fFileType);
288	fWritePictures->AddPopup("&Write Type", fWriteType);
289	fWritePictures->AddPopup("Write &Rate", fWriteRate);
290	fWritePictures->DisableEntry(IDM_kStop);
291	fWritePictures->Associate(this);
292
293	fSetup->AddPopup("Lim. &Magnitude", fLimMag);
294	fSetup->AddPopup("Disp. &Interpolation", fInterpol);
295	fSetup->Associate(this);
296
297	fOperations->AddEntry("Starguider Analysis", IDM_kStargAnalysis);
298	fOperations->DisableEntry(IDM_kStargAnalysis);
299	fOperations->Associate(this);
300
301	fCaOs = new TGPopupMenu(p);
302	fCaOs->AddPopup("&Write", fCaosWrite);
303	fCaOs->AddPopup("&Print", fCaosPrint);
304	fCaOs->AddPopup("&Analyse", fCaosAnalyse);
305	fCaOs->Associate(this);
306	fList->Add(fCaOs);
307
308	fGStarg = new MGStarg(this, 235);
309	fGStarg->Move(530,596+5);
310	fList->Add(fGStarg);
311
312	//RA,Dec for catalog
313	fCRaDec = new MGCoordinates(this, kETypeRaDec);
314	fCRaDec->Move(4, fMenu->GetDefaultHeight()+584);
315	AddFrame(fCRaDec);
316
317	//telescope position
318	fCZdAz = new MGCoordinates(this, kETypeZdAz, 2);
319	fCZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+597);
320	AddFrame(fCZdAz);
321
322	//starguider position
323	fPZdAz = new MGCoordinates(this, kETypeZdAz, 2);
324	fPZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+640);
325	AddFrame(fPZdAz);
326
327	//mispointing
328	fDZdAz = new MGCoordinates(this, kETypeZdAz, 2);
329	fDZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+683);
330	AddFrame(fDZdAz);
331
332	fSZdAz = new MGCoordinates(this, kETypeZdAz, 2);
333	fSZdAz->Move(240+12+28, fMenu->GetDefaultHeight()+795);
334	AddFrame(fSZdAz);
335
336	fGNumStars = new MGNumStars(this, 235);
337	fGNumStars->DrawText("Number of stars");
338	fGNumStars->Move(278, fMenu->GetDefaultHeight()+713);
339	fList->Add(fGNumStars);
340
341	fTPoint = new TGTextButton(this, "TPoint");
342	//fTPoint->Move(4, fMenu->GetDefaultHeight()+785);
343	fTPoint->Move(170, fMenu->GetDefaultHeight()+785);
344	fTPoint->AllowStayDown(kTRUE);
345	AddFrame(fTPoint);
346	/*
347	fStargTPoint = new TGTextButton(this, "StargTPoint");
348	fStargTPoint->Move(170, fMenu->GetDefaultHeight()+785);
349	fStargTPoint->AllowStayDown(kTRUE);
350	AddFrame(fStargTPoint);
351	*/
352
353	fFps = new TGLabel(this, "---fps");
354	fFps->SetTextJustify(kTextRight);
355	fFps->Move(650-495, fMenu->GetDefaultHeight()+714+23);
356	AddFrame(fFps);
357
358	fPosZoom = new TGLabel(this, "(----, ----) ----.--d/----.--d");
359	fPosZoom->SetTextJustify(kTextLeft);
360	fPosZoom->Move(4, fMenu->GetDefaultHeight()+765);
361	AddFrame(fPosZoom);
362
363	fSkyBright = new TGLabel(this, "Sky Brightness: --- ");
364	fSkyBright->SetTextJustify(kTextLeft);
365	fSkyBright->Move(4, fMenu->GetDefaultHeight()+785);
366	AddFrame(fSkyBright);
367
368	TGLabel *l = new TGLabel(this, "deg");
369	l->SetTextJustify(kTextLeft);
370	l->Move(606-412, fMenu->GetDefaultHeight()+669);
371	AddFrame(l);
372
373	l = new TGLabel(this, "arcsec/pix");
374	l->SetTextJustify(kTextLeft);
375	l->Move(606-412, fMenu->GetDefaultHeight()+692);
376	AddFrame(l);
377
378	l = new TGLabel(this, "sigma");
379	l->SetTextJustify(kTextLeft);
380	l->Move(606-412, fMenu->GetDefaultHeight()+715);
381	AddFrame(l);
382
383	fCZdAzText = new TGLabel(this, "Zd/Az telescope pointing at");
384	fCZdAzText->SetTextJustify(kTextLeft);
385	fCZdAzText->Move(240+12+20+7, fMenu->GetDefaultHeight()+584-5);
386	AddFrame(fCZdAzText);
387
388	fPZdAzText = new TGLabel(this, "Zd/Az starguider pointing at");
389	fPZdAzText->SetTextJustify(kTextLeft);
390	fPZdAzText->Move(240+12+20+7, fMenu->GetDefaultHeight()+630+20-5-23);
391	AddFrame(fPZdAzText);
392
393	fDZdAzText = new TGLabel(this, "Zd/Az mispointing");
394	fDZdAzText->SetTextJustify(kTextLeft);
395	fDZdAzText->Move(240+12+20+7, fMenu->GetDefaultHeight()+676+2*20-5-46);
396	AddFrame(fDZdAzText);
397
398	// Set input box for rotation angle
399	fAngle = new TGTextEntry(this, " ", IDM_kAngle);
400	fAngle->SetAlignment(kTextCenterX);
401	fAngle->Move(547-410, fMenu->GetDefaultHeight()+667);
402	AddFrame(fAngle);
403
404	SetRotationAngle(-0.2);
405
406	// Set input box for pixel size
407	fPixSize = new TGTextEntry(this, " ", IDM_kPixSize);
408	fPixSize->SetAlignment(kTextCenterX);
409	fPixSize->Move(547-410, fMenu->GetDefaultHeight()+690);
410	AddFrame(fPixSize);
411
412	SetPixSize(48.9);
413
414	// Set input box for cleaning cut
415	fCut = new TGTextEntry(this, " ", IDM_kCut);
416	fCut->SetAlignment(kTextCenterX);
417	fCut->Move(547-410, fMenu->GetDefaultHeight()+713);
418	AddFrame(fCut);
419
420	SetCut(3.0);
421
422	// TGHorizontal3DLine *fLineSep = new TGHorizontal3DLine(this);
423	// AddFrame(fLineSep, new TGLayoutHints (kLHintsNormal \| kLHintsExpandX));
424	// fList->Add(fLineSep);
425
426	//
427	// Create Image Display
428	//
429	fZoomImage = new MGImage(this, kZOOM, kZOOM);
430	// fZoomImage->Move(768-kZOOM-2, 700-kZOOM-2);
431	fZoomImage->Move(4, 700-kZOOM-2+85);
432	AddFrame(fZoomImage);
433
434	fImage = new MGImage(this, 768, 576);
435	fImage->Move(0, fMenu->GetDefaultHeight());
436	AddFrame(fImage);
437
438	const Int_t w = 768;
439	const Int_t h = 840;
440	SetWMSizeHints(w, h, w, h, 1, 1); // set the smallest and biggest size of the Main frame
441
442	//
443	// Make everything visible
444	//
445	SetWindowName("MStarguider Main Window");
446	SetIconName("MStarguider");
447
448	MapSubwindows();
449	fTPoint->UnmapWindow();
450	//fStargTPoint->UnmapWindow();
451	fGStarg->UnmapWindow();
452	fGNumStars->UnmapWindow();
453	fCRaDec->UnmapWindow();
454	fCZdAz->UnmapWindow();
455	fCZdAzText->UnmapWindow();
456	fPZdAz->UnmapWindow();
457	fPZdAzText->UnmapWindow();
458	fDZdAz->UnmapWindow();
459	fDZdAzText->UnmapWindow();
460	fSZdAz->UnmapWindow();
461	fSkyBright->UnmapWindow();
462	MapWindow();
463
464
465	//IconifyWindow();
466
467	//------------------------------------------------------------
468	// XY xy(3.819444, 24.05333);
469	// fCRaDec->SetCoordinates(xy);
470	// fRaDec->Set(xy.X()*360/24, xy.Y());
471	//------------------------------------------------------------
472	}
473
474	MStarguider::MStarguider(MObservatory::LocationName_t obs, Int_t channel)
475	: TGMainFrame(gClient->GetRoot(), 768, 840),
476	fNumStarsDetected(0),
477	fNumStarsCorrelated(0),
478	fCosy(NULL),
479	fOutTp(0),
480	fOutStargTp(0),
481	// fOutRq(0),
482	fDx((768-kZOOM)/2),
483	fDy((512-kZOOM)/2),
484	fStatus(MDriveCom::kStandby),
485	fRadius(200),
486	fTPointFromCC(-1),
487	fFindStarCut(3.0), fFindStarBox(70)
488	{
489	gLog << warn << " #### FIXME: Make MCaos Thread safe!" << endl;
490
491	// This means that all objects added with AddFrame are deleted
492	// automatically, including all LayoutHints.
493	SetCleanup();
494
495	fSao = new StarCatalog(obs);
496	fRaDec = new RaDec(180, 40);
497
498	fCaos = new MCaos;
499	fStargCaos = new MCaos;
500
501	fStargHistograms = new MStargHistograms();
502
503	InitGui(channel);
504
505	fTimer=new TTimer(this, 1000/25); // 40ms
506	fTimer->TurnOn();
507
508	fTime.Now();
509
510	fTimeFromTp.Clear();
511	fAltAzOffsetFromTp = AltAz(-1000,-1000);
512
513	gVirtualX->GrabButton(fId, kButton2, 0, 0, 0, 0, kTRUE);
514
515	if (channel<0)
516	fGetter = new PngReader(*this);
517	else
518	fGetter = new Camera(*this, channel);
519	}
520
521	void MStarguider::SetRotationAngle(Double_t angle)
522	{
523	fSao->SetRotationAngle(angle);
524
525	TString txt;
526	txt += angle;
527
528	fAngle->SetText(txt);
529	}
530
531	void MStarguider::SetPixSize(Double_t size)
532	{
533	fSao->SetPixSize(size);
534
535	TString txt;
536	txt += size;
537
538	fPixSize->SetText(txt);
539	}
540
541	void MStarguider::SetCut(Double_t cut)
542	{
543	TString txt;
544	txt += cut;
545
546	fCut->SetText(txt);
547	}
548
549	void MStarguider::SetupEnv(TEnv &env)
550	{
551	fCaos->ReadEnv(env, "TPointLeds", kTRUE);
552	fStargCaos->ReadEnv(env, "StarguiderLeds", kTRUE);
553
554	SetRotationAngle(env.GetValue("Starguider.RotationAngle", fSao->GetRotationAngle()));
555	SetCut(env.GetValue("Starguider.CleaningLevel", atof(fCut->GetText())));
556
557	SetPixSize(env.GetValue("StarguiderLeds.ArcsecPerPixel", fSao->GetPixSize()));
558
559	fRadius = env.GetValue("Leds.Radius", fRadius);
560
561	fStarguiderW = env.GetValue("Starguider.Width", fStarguiderW);
562	fStarguiderH = env.GetValue("Starguider.Height", fStarguiderH);
563	fStarguiderX = env.GetValue("Starguider.X", fStarguiderX);
564	fStarguiderY = env.GetValue("Starguider.Y", fStarguiderY);
565
566	fSkyOffsetX = env.GetValue("Starguider.SkyOffsetX", fSkyOffsetX);
567	fSkyOffsetY = env.GetValue("Starguider.SkyOffsetY", fSkyOffsetY);
568
569	fFindStarBox = env.GetValue("FindStar.SizeBox", fFindStarBox);
570	fFindStarCut = env.GetValue("FindStar.CleaningLevel", fFindStarCut);
571	}
572
573	MStarguider::~MStarguider()
574	{
575	fGetter->ExitLoop();
576	delete fGetter;
577
578	gVirtualX->GrabButton(fId, kButton2, 0, 0, 0, 0, kFALSE);
579
580	fTimer->TurnOff();
581	delete fTimer;
582
583	delete fList;
584
585	delete fCaos;
586	delete fStargCaos;
587	delete fStargHistograms;
588	delete fSao;
589	delete fRaDec;
590
591	if (fOutTp)
592	delete fOutTp;
593
594	if (fOutStargTp)
595	delete fOutStargTp;
596
597	// if (fOutRq)
598	// delete fOutRq;
599
600	gLog << inf2 << "Camera Display destroyed." << endl;
601	}
602
603	void MStarguider::Layout()
604	{
605	// Resize(GetDefaultSize());
606	}
607
608	void MStarguider::CloseWindow()
609	{
610	gLog << inf2 << "EventDisplay::CloseWindow: Exit Application Loop." << endl;
611
612	//fClient.ExitLoop();
613	// cout << "FIXME: ExitLoop not called!!!!!!" << endl;
614	fGetter->ExitLoop();
615	gSystem->ExitLoop();
616	}
617
618	void MStarguider::SwitchOff(TGPopupMenu *p, UInt_t id)
619	{
620	p->UnCheckEntry(id);
621	p->DisableEntry(id);
622	}
623
624	void MStarguider::SetChannel()
625	{
626	if (fChannel->IsEntryChecked(IDM_kChannel3))
627	{
628	if (dynamic_cast<PngReader*>(fGetter)==0)
629	{
630	delete fGetter;
631	fGetter=new PngReader(*this);
632	}
633	}
634	else
635	{
636	const Int_t ch = fChannel->IsEntryChecked(IDM_kChannel1) ? 0 : 1;
637	if (dynamic_cast<Camera*>(fGetter)==0)
638	{
639	delete fGetter;
640	fGetter = new Camera(*this, ch);
641	}
642	else
643	fGetter->SetChannel(ch);
644	}
645	}
646
647	void MStarguider::Toggle(TGPopupMenu *p, UInt_t id)
648	{
649	if (p->IsEntryChecked(id))
650	p->UnCheckEntry(id);
651	else
652	p->CheckEntry(id);
653	}
654
655	void MStarguider::ToggleStargAnalysis()
656	{
657	if (fOperations->IsEntryChecked(IDM_kStargAnalysis))
658	fStargHistograms->OpenFile();
659	else
660	fStargHistograms->CloseFile();
661	}
662
663	/*
664	void MStarguider::ToggleFindStar()
665	{
666	if (fDisplay->IsEntryChecked(IDM_kFindStar) && fCosy)
667	fTPoint->MapWindow();
668	else
669	{
670	fTPoint->UnmapWindow();
671	fTPoint->SetDown(kFALSE);
672	}
673	}
674	*/
675	void MStarguider::ToggleStarguider()
676	{
677	if (fDisplay->IsEntryChecked(IDM_kStarguider))
678	{
679	fLastBright = 0xff;
680
681	fChannel->EnableEntry(IDM_kChannel1);
682	fDisplay->DisableEntry(IDM_kFindStar);
683	fDisplay->DisableEntry(IDM_kCaosFilter);
684	fOperations->EnableEntry(IDM_kStargAnalysis);
685
686	//fStargTPoint->MapWindow();
687
688	fPZdAz->MapWindow();
689	fDZdAz->MapWindow();
690	fSkyBright->MapWindow();
691
692	for (int i=IDM_kLimMag3; i<=IDM_kLimMag9; i++)
693	fLimMag->UnCheckEntry(i);
694	fLimMag->CheckEntry(IDM_kLimMag9);
695	fSao->SetLimitMag(9.0);
696
697	for (int i=IDM_kInterpol250; i<=IDM_kInterpol1; i++)
698	fInterpol->UnCheckEntry(i);
699	fInterpol->CheckEntry(IDM_kInterpol125);
700	fIntRate = 125;
701
702	//catalog
703	fDisplay->CheckEntry(IDM_kCatalog);
704	fCRaDec->MapWindow();
705	fCZdAz->MapWindow();
706	fCZdAzText->MapWindow();
707
708	fPZdAz->MapWindow();
709	fPZdAzText->MapWindow();
710	fDZdAz->MapWindow();
711	fDZdAzText->MapWindow();
712
713	fGStarg->MapWindow();
714	fGNumStars->MapWindow();
715
716	SwitchOff(fChannel, IDM_kChannel2);
717	fChannel->CheckEntry(IDM_kChannel1);
718	}
719	else
720	{
721	fStatus = MDriveCom::kStandby;
722
723	//fStargTPoint->UnmapWindow();
724	//fStargTPoint->SetDown(kFALSE);
725
726	fPZdAz->UnmapWindow();
727	fPZdAzText->UnmapWindow();
728	fDZdAz->UnmapWindow();
729	fDZdAzText->UnmapWindow();
730	fSkyBright->UnmapWindow();
731	//catalog
732	fCRaDec->UnmapWindow();
733	fCZdAz->UnmapWindow();
734	fCZdAzText->UnmapWindow();
735	fDisplay->UnCheckEntry(IDM_kCatalog);
736
737	fGStarg->UnmapWindow();
738	fGNumStars->UnmapWindow();
739
740	fChannel->EnableEntry(IDM_kChannel2);
741	fDisplay->EnableEntry(IDM_kFindStar);
742	fDisplay->EnableEntry(IDM_kCaosFilter);
743	fOperations->DisableEntry(IDM_kStargAnalysis);
744	}
745
746	SetChannel();
747	//gSystem->Unlink("tracking_error.txt");
748	}
749
750	void MStarguider::ToggleCaosFilter()
751	{
752	if (fDisplay->IsEntryChecked(IDM_kCaosFilter))
753	{
754	if (!fMode->IsEntryChecked(IDM_kStarguiderMode)
755	&& !fMode->IsEntryChecked(IDM_kTpointMode))
756	fMenu->AddPopup("&CaOs", fCaOs, NULL);
757
758	SwitchOff(fDisplay, IDM_kStarguider);
759	SwitchOff(fDisplay, IDM_kStargCaosFilter);
760	}
761	else
762	{
763	fCaosWrite->UnCheckEntry(IDM_kCaosPrintLeds);
764	fCaosWrite->UnCheckEntry(IDM_kCaosPrintRings);
765
766	if (fCaosAnalyse->IsEntryEnabled(IDM_kCaosAnalStop))
767	{
768	fCaosAnalyse->DisableEntry(IDM_kCaosAnalStop);
769	fCaosAnalyse->EnableEntry(IDM_kCaosAnalStart);
770	fCaos->DeleteHistograms();
771	}
772	if (fCaosWrite->IsEntryEnabled(IDM_kCaosWriteStop))
773	{
774	fCaosWrite->DisableEntry(IDM_kCaosWriteStop);
775	fCaosWrite->EnableEntry(IDM_kCaosWriteStart);
776	fCaos->CloseFile();
777	}
778	fMenu->RemovePopup("CaOs");
779
780	fDisplay->EnableEntry(IDM_kStargCaosFilter);
781	fDisplay->EnableEntry(IDM_kStarguider);
782	}
783	fMenu->Resize(fMenu->GetDefaultSize());
784	MapSubwindows(); // maps everything, but we don't want that
785	fTPoint->UnmapWindow();
786	//fStargTPoint->UnmapWindow();
787	fGStarg->UnmapWindow();
788	fGNumStars->UnmapWindow();
789	fCRaDec->UnmapWindow();
790	fCZdAz->UnmapWindow();
791	fCZdAzText->UnmapWindow();
792	fPZdAz->UnmapWindow();
793	fPZdAzText->UnmapWindow();
794	fDZdAz->UnmapWindow();
795	fDZdAzText->UnmapWindow();
796	fSZdAz->UnmapWindow();
797	fSkyBright->UnmapWindow();
798	MapWindow();
799	}
800
801	Bool_t MStarguider::ProcessMessage(Long_t msg, Long_t mp1, Long_t mp2)
802	{
803	switch (GET_MSG(msg))
804	{
805	case kC_TEXTENTRY:
806	if (GET_SUBMSG(msg)==kTE_ENTER)
807	switch (mp1)
808	{
809	case IDM_kPixSize:
810	{
811	const Float_t pixsize = atof(fPixSize->GetText());
812	gLog << all << "Pixel Size changed to " << pixsize << "\"/pix" << endl;
813	fSao->SetPixSize(pixsize);
814	return kTRUE;
815	}
816	case IDM_kAngle:
817	{
818	const Float_t angle = atof(fAngle->GetText());
819	gLog << all << "Rotation Angle changed to " << angle << "deg" << endl;
820	fSao->SetRotationAngle(angle);
821	return kTRUE;
822	}
823	case IDM_kCut:
824	{
825	const Float_t cut = atof(fCut->GetText());
826	gLog << all << "Starguider cleaning level changed to " << cut << " sigma." << endl;
827	return kTRUE;
828	}
829	}
830	return kTRUE;
831
832	case kC_COMMAND:
833	switch (GET_SUBMSG(msg))
834	{
835	case kCM_MENU:
836	switch (mp1)
837	{
838	case IDM_kCatalog:
839	Toggle(fDisplay, IDM_kCatalog);
840	if (fDisplay->IsEntryChecked(IDM_kCatalog))
841	{
842	fCRaDec->MapWindow();
843	fCZdAz->MapWindow();
844	fCZdAzText->MapWindow();
845	}
846	else
847	{
848	fCRaDec->UnmapWindow();
849	fCZdAz->UnmapWindow();
850	fCZdAzText->UnmapWindow();
851	}
852	return kTRUE;
853
854	case IDM_kStarguider:
855	Toggle(fDisplay, IDM_kStarguider);
856	ToggleStarguider();
857	return kTRUE;
858
859	case IDM_kStargAnalysis:
860	Toggle(fOperations, IDM_kStargAnalysis);
861	ToggleStargAnalysis();
862	return kTRUE;
863
864	case IDM_kStarguiderMode:
865	Toggle(fMode, IDM_kStarguiderMode);
866
867	if (fMode->IsEntryChecked(IDM_kStarguiderMode))
868	{
869	//uncheck not needed items
870	//general
871	SwitchOff(fDisplay, IDM_kFilter);
872	SwitchOff(fChannel, IDM_kChannel3);
873	SwitchOff(fOperations, IDM_kStargAnalysis);
874
875	//tpoint
876	SwitchOff(fDisplay, IDM_kFindStar);
877	SwitchOff(fDisplay, IDM_kCaosFilter);
878	ToggleCaosFilter();
879	fMode->UnCheckEntry(IDM_kTpointMode);
880
881	//enable starguider items
882	fDisplay->EnableEntry(IDM_kStargCaosFilter);
883	fDisplay->EnableEntry(IDM_kStarguider);
884	fDisplay->EnableEntry(IDM_kCatalog);
885
886	//check needed items
887	fDisplay->UnCheckEntry(IDM_kStretch);
888	fDisplay->CheckEntry(IDM_kStargCaosFilter);
889	fDisplay->CheckEntry(IDM_kStarguider);
890	ToggleStarguider();
891
892	fTPoint->MapWindow();
893	}
894	else
895	{
896	//uncheck
897	//starguider items
898	fDisplay->UnCheckEntry(IDM_kStargCaosFilter);
899	fDisplay->UnCheckEntry(IDM_kStarguider);
900	fTPoint->UnmapWindow();
901	ToggleStarguider();
902
903	//general
904	fDisplay->UnCheckEntry(IDM_kCatalog);
905	fDisplay->EnableEntry(IDM_kFilter);
906	fDisplay->EnableEntry(IDM_kCaosFilter);
907	fDisplay->EnableEntry(IDM_kFindStar);
908	fChannel->EnableEntry(IDM_kChannel3);
909	}
910	return kTRUE;
911
912	case IDM_kTpointMode:
913	Toggle(fMode, IDM_kTpointMode);
914
915	if (fMode->IsEntryChecked(IDM_kTpointMode))
916	{
917	//unchecking not needed items
918	//general
919	SwitchOff(fDisplay, IDM_kFilter);
920	SwitchOff(fChannel, IDM_kChannel3);
921
922	//from starguider
923	SwitchOff(fDisplay, IDM_kStargCaosFilter);
924	SwitchOff(fDisplay, IDM_kCatalog);
925	SwitchOff(fDisplay, IDM_kStarguider);
926	ToggleStarguider();
927	fMode->UnCheckEntry(IDM_kStarguiderMode);
928	SwitchOff(fOperations, IDM_kStargAnalysis);
929	ToggleStargAnalysis();
930
931	//switch camera
932	SwitchOff(fChannel, IDM_kChannel1);
933	fChannel->CheckEntry(IDM_kChannel2);
934
935	SetChannel();
936
937	//checking needed items
938	fDisplay->UnCheckEntry(IDM_kStretch);
939	fDisplay->CheckEntry(IDM_kCaosFilter);
940	ToggleCaosFilter();
941	fDisplay->CheckEntry(IDM_kFindStar);
942	fTPoint->MapWindow();
943	}
944	else
945	{
946	//enable
947	//starguider items
948	fDisplay->EnableEntry(IDM_kStargCaosFilter);
949	fDisplay->EnableEntry(IDM_kCatalog);
950	fDisplay->EnableEntry(IDM_kStarguider);
951	fOperations->EnableEntry(IDM_kStargAnalysis);
952
953	//general
954	fDisplay->EnableEntry(IDM_kFilter);
955	fChannel->EnableEntry(IDM_kChannel1);
956	fChannel->EnableEntry(IDM_kChannel3);
957
958	//tpoint
959	fDisplay->UnCheckEntry(IDM_kCaosFilter);
960	ToggleCaosFilter();
961	fDisplay->UnCheckEntry(IDM_kFindStar);
962	fTPoint->UnmapWindow();
963	}
964	return kTRUE;
965
966	case IDM_kFilter:
967	Toggle(fDisplay, IDM_kFilter);
968	return kTRUE;
969
970	case IDM_kFindStar:
971	Toggle(fDisplay, IDM_kFindStar);
972	//ToggleFindStar();
973	return kTRUE;
974
975	case IDM_kStretch:
976	Toggle(fDisplay, IDM_kStretch);
977	return kTRUE;
978
979	case IDM_kCaosFilter:
980	Toggle(fDisplay, IDM_kCaosFilter);
981	ToggleCaosFilter();
982	return kTRUE;
983
984	case IDM_kStargCaosFilter:
985	Toggle(fDisplay, IDM_kStargCaosFilter);
986	if (fDisplay->IsEntryChecked(IDM_kStargCaosFilter))
987	{
988	SwitchOff(fDisplay, IDM_kCaosFilter);
989	SwitchOff(fDisplay, IDM_kFindStar);
990	SwitchOff(fDisplay, IDM_kFilter);
991	}
992	else
993	{
994	fDisplay->EnableEntry(IDM_kFilter);
995	fDisplay->EnableEntry(IDM_kFindStar);
996	fDisplay->EnableEntry(IDM_kCaosFilter);
997	}
998	return kTRUE;
999
1000	case IDM_kCaosPrintLeds:
1001	case IDM_kCaosPrintRings:
1002	Toggle(fCaosPrint, mp1);
1003	return kTRUE;
1004
1005	case IDM_kCaosAnalStart:
1006	fCaosAnalyse->DisableEntry(IDM_kCaosAnalStart);
1007	fCaosAnalyse->EnableEntry(IDM_kCaosAnalStop);
1008	fCaos->InitHistograms();
1009	return kTRUE;
1010
1011	case IDM_kCaosAnalStop:
1012	fCaosAnalyse->DisableEntry(IDM_kCaosAnalStop);
1013	fCaosAnalyse->EnableEntry(IDM_kCaosAnalStart);
1014	fCaos->ShowHistograms();
1015	fCaos->DeleteHistograms();
1016	return kTRUE;
1017
1018	case IDM_kCaosWriteStart:
1019	fCaosWrite->DisableEntry(IDM_kCaosWriteStart);
1020	fCaosWrite->EnableEntry(IDM_kCaosWriteStop);
1021	fCaos->OpenFile();
1022	return kTRUE;
1023
1024	case IDM_kCaosWriteStop:
1025	fCaosWrite->DisableEntry(IDM_kCaosWriteStop);
1026	fCaosWrite->EnableEntry(IDM_kCaosWriteStart);
1027	fCaos->CloseFile();
1028	return kTRUE;
1029
1030	case IDM_kStart:
1031	fWritePictures->DisableEntry(IDM_kStart);
1032	fWritePictures->EnableEntry(IDM_kStop);
1033	return kTRUE;
1034
1035	case IDM_kStop:
1036	fWritePictures->DisableEntry(IDM_kStop);
1037	fWritePictures->EnableEntry(IDM_kStart);
1038	return kTRUE;
1039
1040	case IDM_kPNG:
1041	fFileType->CheckEntry(IDM_kPNG);
1042	fFileType->UnCheckEntry(IDM_kPPM);
1043	return kTRUE;
1044
1045	case IDM_kPPM:
1046	fFileType->CheckEntry(IDM_kPPM);
1047	fFileType->UnCheckEntry(IDM_kPNG);
1048	return kTRUE;
1049
1050	case IDM_kOnce:
1051	fWriteType->CheckEntry(IDM_kOnce);
1052	fWriteType->UnCheckEntry(IDM_kContinous);
1053	return kTRUE;
1054
1055	case IDM_kContinous:
1056	fWriteType->CheckEntry(IDM_kContinous);
1057	fWriteType->UnCheckEntry(IDM_kOnce);
1058	return kTRUE;
1059
1060	case IDM_kRate25ps:
1061	case IDM_kRate5ps:
1062	case IDM_kRate1s:
1063	case IDM_kRate5s:
1064	case IDM_kRate30s:
1065	case IDM_kRate1m:
1066	case IDM_kRate5m:
1067	for (int i=IDM_kRate25ps; i<=IDM_kRate5m; i++)
1068	if (mp1==i)
1069	fWriteRate->CheckEntry(i);
1070	else
1071	fWriteRate->UnCheckEntry(i);
1072	switch (mp1)
1073	{
1074	case IDM_kRate25ps:
1075	fWrtRate = 1;
1076	return kTRUE;
1077	case IDM_kRate5ps:
1078	fWrtRate = 5;
1079	return kTRUE;
1080	case IDM_kRate1s:
1081	fWrtRate = 25;
1082	return kTRUE;
1083	case IDM_kRate5s:
1084	fWrtRate = 5*25;
1085	return kTRUE;
1086	case IDM_kRate30s:
1087	fWrtRate = 30*25;
1088	return kTRUE;
1089	case IDM_kRate1m:
1090	fWrtRate = 60*25;
1091	return kTRUE;
1092	case IDM_kRate5m:
1093	fWrtRate = 56025;
1094	return kTRUE;
1095	}
1096	return kTRUE;
1097
1098	case IDM_kChannel1:
1099	case IDM_kChannel2:
1100	{
1101	const Int_t ch0 = fChannel->IsEntryChecked(IDM_kChannel1) ? 0 : 1;
1102	const Int_t ch1 = mp1==IDM_kChannel1 ? 0 : 1;
1103
1104	if (ch0==ch1)
1105	return kTRUE;
1106
1107	fChannel->CheckEntry (ch1==0?IDM_kChannel1:IDM_kChannel2);
1108	fChannel->UnCheckEntry(ch1==1?IDM_kChannel1:IDM_kChannel2);
1109
1110	SetChannel();
1111	}
1112	return kTRUE;
1113
1114	case IDM_kInterpol250:
1115	case IDM_kInterpol125:
1116	case IDM_kInterpol50:
1117	case IDM_kInterpol25:
1118	case IDM_kInterpol10:
1119	case IDM_kInterpol5:
1120	case IDM_kInterpol2:
1121	case IDM_kInterpol1:
1122	for (int i=IDM_kInterpol250; i<=IDM_kInterpol1; i++)
1123	if (mp1==i)
1124	fInterpol->CheckEntry(i);
1125	else
1126	fInterpol->UnCheckEntry(i);
1127	switch (mp1)
1128	{
1129	case IDM_kInterpol1:
1130	fIntRate = 1;
1131	return kTRUE;
1132	case IDM_kInterpol2:
1133	fIntRate = 2;
1134	return kTRUE;
1135	case IDM_kInterpol5:
1136	fIntRate = 5;
1137	return kTRUE;
1138	case IDM_kInterpol10:
1139	fIntRate = 10;
1140	return kTRUE;
1141	case IDM_kInterpol25:
1142	fIntRate = 25;
1143	return kTRUE;
1144	case IDM_kInterpol50:
1145	fIntRate = 50;
1146	return kTRUE;
1147	case IDM_kInterpol125:
1148	fIntRate = 125;
1149	return kTRUE;
1150	case IDM_kInterpol250:
1151	fIntRate = 250;
1152	return kTRUE;
1153	}
1154	return kTRUE;
1155
1156	case IDM_kLimMag3:
1157	case IDM_kLimMag4:
1158	case IDM_kLimMag5:
1159	case IDM_kLimMag6:
1160	case IDM_kLimMag7:
1161	case IDM_kLimMag8:
1162	case IDM_kLimMag9:
1163	for (int i=IDM_kLimMag3; i<=IDM_kLimMag9; i++)
1164	if (mp1==i)
1165	fLimMag->CheckEntry(i);
1166	else
1167	fLimMag->UnCheckEntry(i);
1168
1169	fSao->SetLimitMag(mp1-IDM_kLimMag3+3);
1170	return kTRUE;
1171	}
1172	break;
1173	}
1174	break;
1175	}
1176
1177	return kTRUE;
1178	}
1179
1180	void MStarguider::SetPointingPosition(RaDec rd)
1181	{
1182	rd.Ra(rd.Ra()*24/360);
1183	fCRaDec->SetCoordinates(rd);
1184	}
1185
1186	ZdAz MStarguider::TrackingError(TArrayF &x, TArrayF &y, TArrayF &mag,
1187	Int_t &num) const
1188	{
1189	num = -1;
1190
1191	// Width of the final 2D gaussian
1192	const Double_t width = 0.8;
1193
1194	// The binning is made 1.7 sigma (which, in the 1D case, gives the
1195	// highest significance of a gaussian signal) (1bin equiv 3x3 sigma)
1196	const Double_t max = 50;
1197	const Int_t n = TMath::Nint(2max/(1.771.7*width));
1198	//1.77=sqrt(pi) comes from pir=bin
1199
1200	// Fill a histogram with the dx/dy values from the file
1201	TH2F hist("Hist", "dX/dY", n, -max, max, n, -max, max);
1202	// hist.SetDirectory(0);
1203
1204	//
1205	// Search for matching Magnitudes
1206	//
1207	//for (int i=0; i<mag.GetSize(); i++)
1208	//{
1209	// if (mag[i]>48-15 && mag[i]<48+15)
1210	// h.Fill(x[i], y[i]);
1211	//}
1212
1213	// fill dx and dy into histogram
1214	for (int i=0; i<mag.GetSize(); i++)
1215	hist.Fill(x[i], y[i]);
1216
1217	// Remove all bins which have content of only a single event
1218	// including under- and overflow bins
1219	for (int i=0; i<hist.GetSize(); i++)
1220	if (hist.GetBinContent(i)<1.5)
1221	hist.SetBinContent(i, 0);
1222
1223	// Find the bin containing the maximum
1224	Int_t bx, by, bz;
1225	hist.GetMaximumBin(bx, by, bz);
1226
1227	// In the worst case the events are spread through the
1228	// bins which are the neighbors of the maximum
1229	// Normally neighbors which do not belong to the signal are empty!
1230	hist.GetXaxis()->SetRange(bx-1, bx+1); // 3x3bins ~8x8pix ~9x9sigma
1231	hist.GetYaxis()->SetRange(by-1, by+1); // 3x3bins ~8x8pix ~9x9sigma
1232
1233	// Check whether this region contains events
1234	num = TMath::Nint(hist.Integral());
1235	if (num<1)
1236	return ZdAz();
1237
1238	// Get Mean for the given axis range
1239	Double_t mx = hist.GetMean(1);
1240	Double_t my = hist.GetMean(2);
1241
1242	const Int_t max1 = TMath::Nint(hist.GetBinContent(bx, by));
1243
1244	// Check if the maximum is unique
1245	Int_t bx2, by2, bz2;
1246	hist.GetXaxis()->SetRange(-1, 9999);
1247	hist.GetYaxis()->SetRange(-1, 9999);
1248	hist.SetBinContent(bx, by, 0);
1249	hist.GetMaximumBin(bx2, by2, bz2);
1250
1251	const Int_t max2 = TMath::Nint(hist.GetBinContent(bx2, by2));
1252	if (max1==max2 && TMath::Abs(bx2-bx)+TMath::Abs(by2-by)>1)
1253	return ZdAz();
1254
1255	// loop again over the file and fill the histogram again.
1256	// to get closer to the correct value
1257	Double_t sumx = 0;
1258	Double_t sumy = 0;
1259	num = 0;
1260	for (int i=0; i<mag.GetSize(); i++)
1261	{
1262	// only fill values into the histogram which
1263	// are inside 2*1.7=3.4 sigma (99.7%)
1264	if (TMath::Hypot(x[i]-mx, y[i]-my)>width*3.4)
1265	continue;
1266
1267	sumx += x[i];
1268	sumy += y[i];
1269	num++;
1270	}
1271
1272	if (num<1)
1273	return ZdAz();
1274
1275	// calc MeanX and MeanY
1276	mx = sumx/num;
1277	my = sumy/num;
1278
1279	// loop again to fill the mispointing corrected histograms
1280	// and fill another histogram to check the quality of the calculated
1281	// mispointing.
1282	sumx = 0;
1283	sumy = 0;
1284	num = 0;
1285	for (int i=0; i<mag.GetSize(); i++)
1286	{
1287	// only fill values into the histogram which
1288	// are inside 1.7=3.4 sigma (92%)
1289	// Cut at 1.7 sigma which gives the best background supression
1290	if (TMath::Hypot(x[i]-mx, y[i]-my)>width*1.7)
1291	continue;
1292
1293	sumx += x[i];
1294	sumy += y[i];
1295	num++;
1296	}
1297
1298	if (num<1)
1299	return ZdAz(); // FIXME!!!!!!!!!!!!
1300
1301	// Mispointing
1302	mx = sumx/num;
1303	my = sumy/num;
1304
1305	#ifdef EXPERT
1306	cout << "Offset-XY: " << mx << " +- " << my << endl;
1307	#endif
1308
1309	return fSao->CalcDeltaZdAzFromPix(mx, my)*TMath::RadToDeg();
1310	/*
1311	AltAz pos0 = fSao->CalcAltAzFromPix(768/2, 576/2)*kRad2Deg;
1312	AltAz pos1 = fSao->CalcAltAzFromPix(768/2+mx, 576/2+my)*kRad2Deg;
1313
1314	pos1 -= pos0;
1315
1316	ZdAz res2 = ZdAz(-pos1.Alt(), pos1.Az());
1317
1318	return res1;
1319	*/
1320	}
1321
1322	Int_t MStarguider::CalcTrackingError(const Leds &leds, MStarList &stars,
1323	ZdAz &d, const MTime &t, const double &bright,
1324	Int_t &num, const Ring &center, Int_t numleds, Int_t numrings)
1325	{
1326	// Get tracking coordinates
1327	const XY xy = fCRaDec->GetCoordinates();
1328
1329	num = leds.GetEntries();
1330	if (num < 3) //was 1
1331	{
1332	gLog << warn << "Sorry, less than 3 detected spot in FOV!" << endl;
1333	if (fTPoint->IsDown() && fCosy && fCosy->GetDriveCom())
1334	fCosy->GetDriveCom()->SendTPoint(false, 'S', fTPointStarMag, fTPointStarName, AltAz(), ZdAz(), xy, 0, 0, t, center, Led(), numleds, numrings, num); // Report
1335	fTPoint->SetDown(kFALSE);
1336	return 0;
1337	}
1338
1339	if (stars.GetRealEntries() < 3)
1340	{
1341	gLog << warn << "Sorry, less than 3 stars in FOV!" << endl;
1342	if (fTPoint->IsDown() && fCosy && fCosy->GetDriveCom())
1343	fCosy->GetDriveCom()->SendTPoint(false, 'S', fTPointStarMag, fTPointStarName, AltAz(), ZdAz(), xy, 0, 0, t, center, Led(), numleds, numrings, num); // Report
1344	fTPoint->SetDown(kFALSE);
1345	return 0;
1346	}
1347
1348	stars.Sort(); // Sort by magnitude
1349
1350	#ifdef EXPERT
1351	TString str = "data/tracking_";
1352	str += fSao->GetMjd();
1353	str += ".txt";
1354
1355	ofstream fout(str);
1356	#endif
1357
1358	TArrayF x, y, mag;
1359
1360	// FIXME: Is predefined value 3 a good idea?
1361	Int_t cnt=0;
1362
1363	MStar *star=0;
1364	MStarListIter NextStar(&stars);
1365	while ((star=NextStar()) && cnt<num+5)
1366	{
1367	TIter NextSp(&leds);
1368	Led *spot=NULL;
1369	while ((spot=(Led*)NextSp()))
1370	{
1371	const XY dpos(spot->GetX()-(768-star->GetX()),
1372	spot->GetY()-star->GetY());
1373
1374	const Int_t idx = x.GetSize();
1375
1376	x.Set(idx+1);
1377	y.Set(idx+1);
1378	mag.Set(idx+1);
1379
1380	x.AddAt(dpos.X(), idx);
1381	y.AddAt(dpos.Y(), idx);
1382	mag.AddAt(1, idx);
1383	// mag.AddAt(log(spot->GetMag())/star->GetMag(), idx);
1384	/*
1385	#ifdef EXPERT
1386	if (fout)
1387	{
1388	fout << spot->GetX() << " "
1389	<< spot->GetY() << " "
1390	<< -2.5*log(spot->GetMag()) << " "
1391	<< star->GetX() << " "
1392	<< star->GetY() << " "
1393	<< star->GetMag() << " ";
1394	fout << x[idx] << " " << y[idx] << " " << mag[idx] << endl;
1395	}
1396	#endif
1397	*/
1398	}
1399	cnt++;
1400	}
1401
1402	Int_t numcor = 0;
1403	d = TrackingError(x, y, mag, numcor);
1404	if (numcor<1)
1405	{
1406	fTPoint->SetDown(kFALSE);
1407	if (fTPoint->IsDown() && fCosy && fCosy->GetDriveCom())
1408	fCosy->GetDriveCom()->SendTPoint(false, 'S', fTPointStarMag, fTPointStarName, AltAz(), ZdAz(), xy, 0, 0, t, center, Led(), numleds, numrings, num, numcor); // Report
1409	return 0;
1410	}
1411
1412	fDZdAz->SetCoordinates(d);
1413
1414	//
1415	// Current Pointing position
1416	//
1417	ZdAz cpos = fSao->GetZdAz()-d;
1418	fPZdAz->SetCoordinates(cpos);
1419
1420	// Check StargTPoint data set request
1421	if (!fMode->IsEntryChecked(IDM_kStarguiderMode) \|\| !fTPoint->IsDown())
1422	return numcor;
1423	fTPoint->SetDown(kFALSE);
1424
1425	// If no file open: open new file
1426	if (!fOutStargTp)
1427	{
1428	// open tpoint file
1429	const TString name = MCosy::GetFileName("tpoint", "starg", "txt");
1430	gLog << all << "TPoint-Starg File ******* " << name << " ******** " << endl;
1431
1432	fOutStargTp = new ofstream(name);
1433	*fOutStargTp << "Magic Model STARGTPOINT data file" << endl;
1434	*fOutStargTp << ": ALTAZ" << endl;
1435	*fOutStargTp << "49 48 0 ";
1436	*fOutStargTp << t << endl;
1437	}
1438
1439	const RaDec rd(xy.X()MAstro::HorToRad(), xy.Y()TMath::DegToRad());
1440
1441	// From the star position in the camera we calculate the Alt/Az
1442	// position we are currently tracking (real pointing position)
1443	fSao->SetMjd(t.GetMjd());
1444	AltAz za0 = fSao->CalcAltAz(rd)*kRad2Deg;
1445
1446	//correction with offset from last tpoint measurement
1447	za0 -= fAltAzOffsetFromTp;
1448
1449	//if the difference between the tpoint and the starguider tpoint
1450	//is too big, the starguider tpoint is not stored
1451	if ((t.GetMjd()-fTimeFromTp.GetMjd())>0.001) //1min20sec
1452	{
1453	cout << " time difference between tpoint and starguider-tpoint > 1m20s" << endl;
1454	cout << " => starguider tpoint hasn't been stored. " << endl;
1455	cout << " Please repeat whole procedure. " << endl;
1456	return numcor;
1457	}
1458
1459
1460	// Write real pointing position
1461	*fOutStargTp << setprecision(7) << za0.Az() << " " << za0.Alt() << " ";
1462
1463	// Write system pointing position
1464	*fOutStargTp << fmod(cpos.Az()+360, 360) << " " << 90-cpos.Zd();
1465
1466	*fOutStargTp << " " << xy.X() << " " << xy.Y();
1467	*fOutStargTp << " " << d.Zd() << " " << d.Az();
1468	*fOutStargTp << " " << setprecision(11) << t.GetMjd();
1469	*fOutStargTp << " " << setprecision(4) << center.GetMag();
1470	*fOutStargTp << " 0";// << star->GetMag();
1471	*fOutStargTp << " " << center.GetX() << " " << center.GetY();
1472	*fOutStargTp << " 0 0";
1473	*fOutStargTp << " " << numleds << " " << numrings;
1474	*fOutStargTp << " " << num << " " << numcor << " " << bright;
1475	*fOutStargTp << " " << fTPointStarMag << " " << fTPointStarName;
1476	*fOutStargTp << endl;
1477
1478	gLog << all << "Starguider TPoint successfully taken." << endl;
1479
1480	fTimeFromTp.Clear();
1481
1482	if (!fCosy)
1483	return numcor;
1484
1485	MDriveCom *com = fCosy->GetDriveCom();
1486	if (!com)
1487	return numcor;
1488
1489	com->SendTPoint(true, 'S', fTPointStarMag, fTPointStarName, za0, cpos, xy, d.Zd(), d.Az(), t, center, Led(), numleds, numrings, num, numcor); // Report
1490
1491	return numcor;
1492	}
1493
1494	void MStarguider::FindStar(const FilterLed &f, const FilterLed &f2, const Ring &center, const MTime &t, Int_t numleds, Int_t numrings)
1495	{
1496	// Get tracking coordinates
1497	const XY xy = fCRaDec->GetCoordinates(); // [h, deg]
1498
1499	if (center.GetX()<=0 && center.GetY()<=0)
1500	{
1501	gLog << warn << "Couldn't determine center of the camera." << endl;
1502	if (fTPoint->IsDown() && fCosy && fCosy->GetDriveCom())
1503	fCosy->GetDriveCom()->SendTPoint(false, 'T', fTPointStarMag, fTPointStarName, AltAz(), ZdAz(), xy, 0, 0, t, center, Led(), numleds, numrings); // Report
1504	return;
1505	}
1506
1507	// Try to find the star
1508	Leds leds;
1509	f.FindStar(leds, (Int_t)center.GetX(), (Int_t)center.GetY(), true);
1510
1511	// Check whether star found
1512	Led star = (Led)leds.At(0);
1513	if (!star)
1514	{
1515	gLog << warn << "No star found." << endl;
1516	if (fTPoint->IsDown() && fCosy && fCosy->GetDriveCom())
1517	fCosy->GetDriveCom()->SendTPoint(false, 'T', fTPointStarMag, fTPointStarName, AltAz(), ZdAz(), xy, 0, 0, t, center, Led(), numleds, numrings); // Report
1518	return;
1519	}
1520
1521	cout << "Found star @ " << flush;
1522	star->Print();
1523	f2.MarkPoint(star->GetX(), star->GetY(), 2<<2);
1524
1525	const RaDec rd(xy.X()MAstro::HorToRad(), xy.Y()TMath::DegToRad());
1526
1527	// Initialize Star Catalog on the camera plane
1528	MGeomCamMagic geom;
1529	MAstroCamera ac;
1530	ac.SetGeom(geom);
1531	ac.SetRadiusFOV(3);
1532	ac.SetObservatory(*fSao);
1533	ac.SetTime(t);
1534	ac.SetRaDec(rd.Ra(), rd.Dec());
1535
1536	// Convert from Pixel to millimeter (1pix=2.6mm) [deg/pix / deg/mm = mm/pix]
1537	// Correct for abberation.
1538	const Double_t conv = fCaos->GetArcsecPerPixel()/3600/geom.GetConvMm2Deg()/ 1.0713;
1539
1540	// Adapt coordinate system (GUIs and humans are counting Y in different directions)
1541	const Double_t dx = (star->GetX()-center.GetX())*conv;
1542	const Double_t dy = (center.GetY()-star->GetY())*conv;
1543
1544	// Convert offset from camera plane into local ccordinates
1545	Double_t dzd, daz;
1546	ac.GetDiffZdAz(dx, dy, dzd, daz);
1547
1548	ZdAz zdaz(dzd,daz);
1549
1550	// Check TPoint data set request
1551	if (!fMode->IsEntryChecked(IDM_kTpointMode) \|\| !fTPoint->IsDown())
1552	return;
1553
1554	// If no file open: open new file
1555	if (!fOutTp)
1556	{
1557	//
1558	// open tpoint file
1559	//
1560	const TString name = MCosy::GetFileName("tpoint", "tpoint", "txt");
1561	cout << "TPoint File ******* " << name << " ******** " << endl;
1562
1563	fOutTp = new ofstream(name);
1564	*fOutTp << "Magic Model TPOINT data file" << endl;
1565	*fOutTp << ": ALTAZ" << endl;
1566	*fOutTp << "49 48 0 ";
1567	*fOutTp << t << endl;
1568	// temp(°C) pressure(mB) height(m) humidity(1) wavelength(microm) troplapserate(K/m)
1569	}
1570
1571	// Output Ra/Dec the drive system thinks that it is currently tracking
1572	//cout << "TPoint Star: " << xy.X() << "h " << xy.Y() << "°" << endl;
1573
1574	// From the star position in the camera we calculate the Alt/Az
1575	// position we are currently tracking (real pointing position)
1576	fSao->SetMjd(t.GetMjd());
1577	AltAz za0 = fSao->CalcAltAz(rd)*kRad2Deg;
1578
1579	//ZdAz za0 = fSao->GetZdAz();
1580	za0 -= AltAz(-dzd, daz);
1581	fAltAzOffsetFromTp = AltAz(-dzd, daz);
1582	fTimeFromTp=t;
1583
1584	// From the Shaftencoders we get the current 'pointing' position
1585	// as it is seen by the drive system (system pointing position)
1586	const ZdAz za1 = fCosy->GetSePos()*360; // [deg]
1587
1588
1589	// Write real pointing position
1590	//cout << " Alt/Az: " << za0.Alt() << "° " << za0.Az() << "°" << endl;
1591	*fOutTp << setprecision(7) << za0.Az() << " " << za0.Alt() << " ";
1592
1593	// Write system pointing position
1594	//cout << " SE-Pos: " << 90-za1.Zd() << "° " << za1.Az() << "°" << endl;
1595	*fOutTp << fmod(za1.Az()+360, 360) << " " << 90-za1.Zd();
1596
1597	*fOutTp << " " << xy.X() << " " << xy.Y();
1598	*fOutTp << " " << -dzd << " " << -daz;
1599	*fOutTp << " " << setprecision(11) << t.GetMjd();
1600	*fOutTp << " " << setprecision(4) << center.GetMag();
1601	*fOutTp << " " << star->GetMag();
1602	*fOutTp << " " << center.GetX() << " " << center.GetY();
1603	*fOutTp << " " << star->GetX() << " " << star->GetY();
1604	*fOutTp << " " << numleds << " " << numrings;
1605	*fOutTp << " 0 0 0";
1606	*fOutTp << " " << fTPointStarMag << " " << fTPointStarName;
1607	*fOutTp << endl;
1608
1609	gLog << all << "TPoint successfully taken." << endl;
1610	/*
1611	MLog &outrep = *fCosy->GetOutRep();
1612	if (outrep.Lock("MStarguider::FindStar"))
1613	{
1614	outrep << "FINDSTAR-REPORT 00 " << MTime(-1) << " " << setprecision(7);
1615	outrep << 90-za0.Alt() << " " << za0.Az() << " ";
1616	outrep << za1.Zd() << " " << za1.Az() << " ";
1617	outrep << xy.X() << " " << xy.Y() << " ";
1618	outrep << -dzd << " " << -daz << " ";
1619	outrep << star->GetX() << " " << star->GetY() << " ";
1620	outrep << center.GetX() << " " << center.GetY() << " ";
1621	outrep << dx/conv << " " << dy/conv << " " << star->GetMag();
1622	outrep << setprecision(11) << t.GetMjd() << endl;
1623	outrep.UnLock("MStarguider::FindStar");
1624	}*/
1625
1626	// return zdaz;
1627
1628	if (!fCosy)
1629	return;
1630
1631	MDriveCom *com = fCosy->GetDriveCom();
1632	if (!com)
1633	return;
1634
1635	com->SendTPoint(true, 'T', fTPointStarMag, fTPointStarName, za0, za1, xy, -dzd, -daz, t, center, *star, numleds, numrings); // Report
1636	}
1637
1638	bool MStarguider::Interpolate(const unsigned long n, byte *img) const
1639	{
1640	if (fIntRate<=1)
1641	return true;
1642
1643	static unsigned short myimg[768*576];
1644
1645	unsigned short *f = myimg;
1646
1647	const byte end = img+768576;
1648
1649	if (n%fIntRate)
1650	{
1651	while (img<end)
1652	f++ += img++;
1653	return false;
1654	}
1655	else
1656	{
1657	while (img<end)
1658	{
1659	img = (img + *f)/fIntRate;
1660	++img;
1661	*f++ = 0;
1662	}
1663
1664	return true;
1665	}
1666	}
1667
1668	void MStarguider::DrawZoomImage(const byte *img)
1669	{
1670	byte zimg[kZOOM*kZOOM];
1671	for (int y=0; y<kZOOM; y++)
1672	for (int x=0; x<kZOOM; x++)
1673	zimg[x+ykZOOM] = img[(fDx+(x-kZOOM/2)/2)+(fDy+(y-kZOOM/2)/2)768];
1674
1675	fZoomImage->DrawImg(zimg);
1676	}
1677
1678	void MStarguider::DrawCosyImage(const byte *img)
1679	{
1680	if (!fCosy)
1681	return;
1682
1683	byte simg[(768/2-1)*(576/2-1)];
1684	for (int y=0; y<576/2-1; y++)
1685	for (int x=0; x<768/2-1; x++)
1686	simg[x+y(768/2-1)] = ((unsigned int)img[2x+2y768]+img[2x+2y768+1]+img[2x+2(y+1)768]+img[2x+2(y+1)*768+1])/4;
1687
1688	fCosy->GetWin()->GetImage()->DrawImg(simg);
1689	}
1690
1691	void MStarguider::StartTPoint(char *cmd)
1692	{
1693	fTPointStarName = "Dummy";
1694	fTPointStarMag = 0;
1695
1696	TString str(cmd);
1697
1698	TObjArray *arr = str.Tokenize(' ');
1699
1700	if (arr->GetEntries()==2)
1701	{
1702	fTPointStarName = (*arr)[0]->GetName();
1703	fTPointStarMag = atof((*arr)[1]->GetName());
1704	}
1705
1706	delete arr;
1707
1708	if (fTPointFromCC<0)
1709	fTPointFromCC=0;
1710	}
1711
1712	void MStarguider::StartStarguider(bool on)
1713	{
1714	// Switch to starguider mode
1715	if (on)
1716	{
1717	cout << " * Switching Starguider mode on" << endl;
1718	fMode->UnCheckEntry(IDM_kStarguiderMode);
1719	ProcessMessage(MK_MSG(kC_COMMAND, kCM_MENU), IDM_kStarguiderMode, 0);
1720	}
1721	else
1722	{
1723	cout << " * Switching Starguider mode off" << endl;
1724	fMode->CheckEntry(IDM_kStarguiderMode);
1725	ProcessMessage(MK_MSG(kC_COMMAND, kCM_MENU), IDM_kStarguiderMode, 0);
1726	}
1727	}
1728
1729	Int_t MStarguider::GetStarguiderMode() const
1730	{
1731	return fMode->IsEntryChecked(IDM_kStarguiderMode) ? 1 : 2;
1732
1733	}
1734
1735	Bool_t MStarguider::DoTPoint()
1736	{
1737	if (fTPoint->IsDown() && fTPointFromCC<0)
1738	{
1739	fTPointFromCC = 0;
1740	fTPoint->SetDown(kFALSE);
1741	}
1742
1743	if (fTPointFromCC<0)
1744	return kTRUE;
1745
1746	switch (++fTPointFromCC)
1747	{
1748	case 1:
1749	fTimeFromTp.Clear();
1750	fNumStarsDetected = 0;
1751
1752	if (!fMode->IsEntryChecked(IDM_kTpointMode))
1753	{
1754	cout << " * Switching to TPoint mode" << endl;
1755	// Switch to tpoint mode
1756	fMode->UnCheckEntry(IDM_kTpointMode);
1757	ProcessMessage(MK_MSG(kC_COMMAND, kCM_MENU), IDM_kTpointMode, 0);
1758	return kFALSE;
1759	}
1760	fTPointFromCC++;
1761
1762	case 2:
1763	case 3:
1764	cout << " * Waiting one frame" << endl;
1765	// Wait one frame
1766	return kFALSE;
1767
1768	case 4:
1769	cout << " * Taking TPoint" << endl;
1770	fTPoint->SetDown(); // kTRUE
1771	return kTRUE;
1772
1773	case 5:
1774	if (!fTimeFromTp) // TPoint failed
1775	break;
1776	#ifdef FACT
1777	fTPointFromCC = -1;
1778	return kFALSE;
1779	#else
1780	// Switch to starguider mode
1781	cout << " * Switching to Starguider mode" << endl;
1782	fMode->UnCheckEntry(IDM_kStarguiderMode);
1783	ProcessMessage(MK_MSG(kC_COMMAND, kCM_MENU), IDM_kStarguiderMode, 0);
1784	return kFALSE;
1785	#endif
1786	case 6:
1787	case 7:
1788	cout << " * Waiting one frame" << endl;
1789	// Wait one frame
1790	return kFALSE;
1791
1792	case 8:
1793	cout << " * Taking Starguider TPoint" << endl;
1794	fTPoint->SetDown(); // kTRUE
1795	return kTRUE;
1796
1797	// case 9:
1798	// cout << " * Send Report" << endl;
1799	// return kTRUE;
1800
1801	case 9:
1802	cout << " * Switching to TPoint mode" << endl;
1803	// Switch to tpoint mode
1804	fMode->UnCheckEntry(IDM_kTpointMode);
1805	ProcessMessage(MK_MSG(kC_COMMAND, kCM_MENU), IDM_kTpointMode, 0);
1806	fTPointFromCC = -1;
1807	return kFALSE;
1808	}
1809
1810	// Send report
1811	/*
1812	if (!fCosy)
1813	return kTRUE;
1814
1815	MDriveCom *com = fCosy->GetDriveCom();
1816	if (!com)
1817	return kTRUE;
1818
1819	// nominalaz, nominalel, realaz, realel, nomra, nomdec,
1820	// diffaz, diffel, mjd, numleds, artmag
1821
1822	//fTimeFromTp.Clear();
1823	//fStatus==MDriveCom::kMonitoring
1824	//fNumStarsDetected = numstars;
1825	//fNumStarsCorrelated = rc;
1826	com->SendTPoint(fNumStarsCorrelated>0);
1827	*/
1828	return kTRUE;
1829	}
1830
1831	void MStarguider::ProcessFrame(const unsigned long n, byte *img,
1832	struct timeval *tm)
1833	{
1834	static unsigned long n0 = n;
1835
1836	MTime t(*tm);
1837
1838	const Double_t d = t-fTime;
1839	if (d>1)
1840	{
1841	const TString txt = MString::Format("%dfps", (int)((n-n0)/d+.5));
1842	fFps->SetText(txt);
1843	fTime = t;
1844	n0 = n;
1845	}
1846
1847	if (!Interpolate(n, img))
1848	return;
1849
1850	byte cimg[768*576];
1851	memset(cimg, 0, 768*576);
1852
1853	FilterLed f(img, 768, 576, 2.5); // 2.5
1854	FilterLed f2(cimg, 768, 576); // former color 0xb0
1855
1856	if (fDisplay->IsEntryChecked(IDM_kStretch))
1857	f.Stretch();
1858
1859	if (!fWritePictures->IsEntryEnabled(IDM_kStart) &&
1860	(!(n%fWrtRate) \|\| fWriteType->IsEntryChecked(IDM_kOnce)))
1861	{
1862
1863	if (fFileType->IsEntryChecked(IDM_kPNG))
1864	Writer::Png("pix/file", img, tm, fCRaDec->GetCoordinates());
1865
1866	if (fFileType->IsEntryChecked(IDM_kPPM))
1867	Writer::Ppm("pix/file", img, tm, fCRaDec->GetCoordinates());
1868
1869	if (fWriteType->IsEntryChecked(IDM_kOnce))
1870	ProcessMessage(MK_MSG(kC_COMMAND, kCM_MENU), IDM_kStop, 0);
1871	}
1872
1873	// Visual Filter, whole FOV
1874	if (fDisplay->IsEntryChecked(IDM_kFilter))
1875	f.Execute();
1876
1877	if (!DoTPoint())
1878	return;
1879
1880	Int_t numleds = 0;
1881	Int_t numrings = 0;
1882
1883	// Find Center of Camera for Caos and Tpoints
1884	// Ring center;//(-1, -1);
1885	Ring center(5, 5);//(-1, -1);
1886	if (fDisplay->IsEntryChecked(IDM_kCaosFilter))
1887	{
1888	const bool printl = fCaosPrint->IsEntryChecked(IDM_kCaosPrintLeds);
1889	const bool printr = fCaosPrint->IsEntryChecked(IDM_kCaosPrintRings);
1890	ZdAz pos;
1891	if (fCosy)
1892	pos = fCosy->GetPointingPos();
1893
1894	center = fCaos->Run(img, printl, printr, pos, t);
1895
1896	numleds = fCaos->GetNumDetectedLEDs();
1897	numrings = fCaos->GetNumDetectedRings();
1898	}
1899
1900	// Find Star at Center---for Tpoint Procedure
1901	if (fDisplay->IsEntryChecked(IDM_kFindStar))
1902	{
1903	// Set search Paremeters (FIXME: Get them from user input!)
1904	f.SetCut(fFindStarCut);
1905	f.SetBox(fFindStarBox);
1906
1907	FindStar(f, f2, center, t, numleds, numrings);
1908	}
1909
1910	DrawZoomImage(img);
1911	DrawCosyImage(img);
1912
1913	// Position corresponding to the camera center (53.2, 293.6)
1914	Ring sgcenter;//(-1, -1); // Center of camera in SG picture [px]
1915
1916	// Find Center of Camera in Starfield Camera picture
1917	if (fDisplay->IsEntryChecked(IDM_kStargCaosFilter))
1918	{
1919	ZdAz pos;
1920	if (fCosy)
1921	pos = fCosy->GetPointingPos();
1922
1923	sgcenter = fStargCaos->Run(img, kFALSE, kFALSE, pos, t); // [px]
1924
1925	numleds = fStargCaos->GetNumDetectedLEDs();
1926	numrings = fStargCaos->GetNumDetectedRings();
1927	}
1928
1929	// we obtain a list of stars in the FOV from the SAO catalog
1930	if (fDisplay->IsEntryChecked(IDM_kCatalog))
1931	{
1932	MTime time(*tm);
1933
1934	XY xy = fCRaDec->GetCoordinates(); //[h, deg]
1935	fRaDec->Set(xy.X()*15, xy.Y()); //[deg,deg]
1936
1937	UpdatePosZoom();
1938
1939	// Always call SetMjd first!
1940	fSao->SetPointing(time.GetMjd(), *fRaDec);
1941	fCZdAz->SetCoordinates(fSao->GetZdAz());
1942
1943	fSao->SetBox(fStarguiderW, fStarguiderH); // 280 Region of interest around center
1944
1945	// If center of camera cannot be determined sgcenter is (0,0)
1946	const Bool_t centerisvalid = sgcenter.GetX()>0 && sgcenter.GetY()>0;
1947
1948	// We determine the ideal starfield using camera sagging info
1949	// from the LEDs
1950	//Please never change this offsets!!!
1951	// 53.2 and 293.6 are the "preliminary" camera center
1952	// -9 and 28.5 are the offsets of the pointing position in the sky
1953	//const XY off(sgcenter.GetX()- 53.2-9,
1954	// sgcenter.GetY()-293.6+28.5);
1955
1956	// Skycenter
1957	const XY off(sgcenter.GetX() + fSkyOffsetX,
1958	sgcenter.GetY() + fSkyOffsetY);
1959
1960	MStarList stars;
1961	if (centerisvalid)
1962	{
1963	// we obtain stars in the effective star FOV and draw them.
1964	// coordinates are video frame coords.
1965	fSao->CalcStars(stars, fStarguiderX, fStarguiderY, off.X(), off.Y());
1966	fSao->DrawStars(stars, cimg);
1967	}
1968
1969	// There are two corrections to the mispointing
1970	// - Sagging of the camera as measured with the LEDs
1971	// - Star not ideally centered on MAGIC Camera
1972
1973	// Next we evaluate the offset given by the LEDs. This we obtain
1974	// in Zd/Az and add it to the tracking error.
1975	if (fDisplay->IsEntryChecked(IDM_kStarguider))
1976	{
1977	const Float_t cut = atof(fCut->GetText());
1978
1979	Leds spots;
1980	f.SetBox(fStarguiderW, fStarguiderH); // 280
1981	f.SetCut(cut);
1982
1983	double bright;
1984	f.ExecuteAndMark(spots, fStarguiderX, fStarguiderY, bright);
1985
1986	ULong_t color;
1987	gClient->GetColorByName("Green", color);
1988	if (bright> 60)
1989	gClient->GetColorByName("Yellow", color);
1990	if (bright> 85)
1991	gClient->GetColorByName("Orange", color);
1992	if (bright> 95)
1993	gClient->GetColorByName("Red", color);
1994	fSkyBright->SetBackgroundColor(color);
1995
1996	const MString txt = MString::Format("Sky Brightness: %.1f", bright);
1997	fSkyBright->SetText(txt);
1998
1999	const Bool_t brightnessisvalid = bright<1.75*fLastBright &&
2000	bright>30 && bright<110;
2001
2002	fLastBright = bright;
2003
2004	Int_t numstars = 0;
2005	const Int_t rc = CalcTrackingError(spots, stars, fD, t, bright, numstars, sgcenter, numleds, numrings);
2006
2007	const Bool_t monitoring = brightnessisvalid && centerisvalid && fNumStarsCorrelated>2;
2008
2009	fStatus = monitoring ? MDriveCom::kMonitoring : MDriveCom::kError;
2010
2011	if (fCosy)
2012	fPos = fCosy->GetPointingPos();
2013
2014	if (fOperations->IsEntryChecked(IDM_kStargAnalysis))
2015	fStargHistograms->Fill(spots, stars, fD, fSao->GetZdAz(),
2016	sgcenter, bright, fPos, t);
2017
2018	fNumStarsDetected = numstars;
2019	fNumStarsCorrelated = rc;
2020
2021	if (fCosy)
2022	{
2023	MDriveCom *com = fCosy->GetDriveCom();
2024	if (com)
2025	com->SendStargReport(fStatus, fD, fSao->GetZdAz(),
2026	sgcenter, numstars, rc, bright,
2027	time.GetMjd(), numleds, numrings); // Report
2028	}
2029
2030	} //kStarguider
2031
2032	if (centerisvalid && fNumStarsCorrelated>2)
2033	{
2034	// Position around which the circles are drawn.
2035	const Ring skycenter(off.X(), off.Y());
2036
2037	f2.DrawCircle(skycenter, 2.0, 0x0a);
2038
2039	const Double_t ap = fSao->GetPixSize()/3600; //[deg/pix]
2040
2041	f2.DrawCircle(skycenter, 0.10/ap, 0x0a); //0.1deg
2042	f2.DrawHexagon(skycenter, 2.06/ap, 0x0a);
2043	f2.DrawHexagon(skycenter, 3.50/ap, 0x0a);
2044	}
2045
2046	} //CalcStars
2047
2048	if (fTPoint->IsDown())
2049	fTPoint->SetDown(kFALSE);
2050
2051	// Draw Circles around center of Camera
2052	if (fDisplay->IsEntryChecked(IDM_kCaosFilter) &&
2053	center.GetX()>0 && center.GetY()>0)
2054	{
2055	f2.DrawCircle(center, 0x0a);
2056	f2.DrawCircle(center, 7.0,
2057	fDisplay->IsEntryChecked(IDM_kFindStar)?3:0xb0);
2058	f2.DrawCircle(center, 115.0, 0x0a);
2059	f2.DrawCircle(center, 230.0, 0x0a);
2060	f2.DrawCircle(center, 245.0, 0x0a);
2061	}
2062
2063	if (fDisplay->IsEntryChecked(IDM_kStargCaosFilter) &&
2064	sgcenter.GetX()>0 && sgcenter.GetY()>0)
2065	{
2066	f2.DrawCircle(sgcenter, 0x0a);
2067	f2.DrawCircle(sgcenter, 5.0,
2068	fDisplay->IsEntryChecked(IDM_kFindStar)?3:0xb0);
2069	}
2070
2071	if (fDisplay->IsEntryChecked(IDM_kCaosFilter) \|\|
2072	fDisplay->IsEntryChecked(IDM_kCatalog) \|\|
2073	fDisplay->IsEntryChecked(IDM_kFindStar))
2074	fImage->DrawColImg(img, cimg);
2075	else
2076	fImage->DrawImg(img);
2077	}
2078
2079	void MStarguider::UpdatePosZoom()
2080	{
2081	MString txt;/*
2082	if (fDisplay->IsEntryChecked(IDM_kCatalog))
2083	{
2084	// FIXME: Necessary?
2085	fSao->Now();
2086	AltAz aa = fSao->CalcAltAzFromPix(fDx, fDy)*kRad2Deg;
2087	if (aa.Az()<0)
2088	aa.Az(aa.Az()+360);
2089	txt.Form("(%d, %d) %.1fd/%.1fd", fDx, fDy, -aa.Alt(), aa.Az()-180);
2090	}
2091	else*/
2092	txt.Form("(%d, %d)", fDx, fDy);
2093	fPosZoom->SetText(txt);
2094	}
2095
2096	Bool_t MStarguider::HandleDoubleClick(Event_t *event)
2097	{
2098	const Int_t w = fImage->GetWidth();
2099	const Int_t h = fImage->GetHeight();
2100	const Int_t x = fImage->GetX();
2101	const Int_t y = fImage->GetY();
2102
2103	if (!(event->fX>x && event->fX<x+w && event->fY>y && event->fY<y+h))
2104	return kTRUE;
2105
2106	Int_t dx = event->fX-x;
2107	Int_t dy = event->fY-y;
2108
2109	if (dx<kZOOM/4) dx=kZOOM/4;
2110	if (dy<kZOOM/4) dy=kZOOM/4;
2111	if (dx>766-kZOOM/4) dx=766-kZOOM/4;
2112	if (dy>574-kZOOM/4) dy=574-kZOOM/4;
2113
2114	fDx = dx;
2115	fDy = dy;
2116
2117	UpdatePosZoom();
2118	return kTRUE;
2119	}
2120
2121	void MStarguider::Print(TString &str, Double_t deg) const
2122	{
2123	Char_t sgn;
2124	UShort_t d, m, s;
2125
2126	MAstro::Deg2Dms(deg, sgn, d, m, s);
2127
2128	str += MString::Format("%c %03d %02d %03d ", sgn, d, m, s);
2129	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: