Instrument Neutral Distributed Interface INDI  2.0.2
test_scopesim_helper.cpp
Go to the documentation of this file.
1 #include <gtest/gtest.h>
2 #include <gmock/gmock.h>
3 
4 #ifdef HAVE_CONFIG_H
5 #include "config.h"
6 #endif
7 
8 #include <cstdlib>
9 #include <cstring>
10 
11 #include <indilogger.h>
12 #include <indidevapi.h>
13 #include <defaultdevice.h>
14 #include <scopesim_helper.h>
15 #include <telescope_simulator.h>
16 
17 using ::testing::_;
18 using ::testing::StrEq;
19 
20 // Angle tests
21 TEST(AngleTest, CreateAngle)
22 {
23 
24  Angle a = Angle(60, Angle::DEGREES);
25  EXPECT_EQ(a.Degrees(), 60);
26  EXPECT_EQ(a.Hours(), 4);
27  EXPECT_EQ(a.radians(), 60. * M_PI / 180.);
28 
29  a = Angle(1.0, Angle::RADIANS);
30  EXPECT_EQ(a.radians(), 1.0);
31 
32  a = Angle(2.0, Angle::HOURS);
33  EXPECT_EQ(a.Hours(), 2.0);
34  EXPECT_EQ(a.Degrees(), 30.0);
35 
36  EXPECT_EQ(Angle(180).Degrees(), 180);
37  EXPECT_EQ(Angle(-180).Degrees(), 180);
38  EXPECT_EQ(Angle(180).Hours(), 12);
39  EXPECT_EQ(Angle(-180).HoursHa(), 12);
40  EXPECT_EQ(Angle(360).Degrees360(), 0);
41  EXPECT_EQ(Angle(-360).Degrees360(), 0);
42  EXPECT_EQ(Angle(720).Hours(), 0);
43  EXPECT_EQ(Angle(360).HoursHa(), 0);
44  EXPECT_EQ(Angle(-345).Hours(), 1);
45  EXPECT_EQ(Angle(-345).HoursHa(), 1);
46  EXPECT_EQ(Angle(345).Hours(), 23);
47  EXPECT_EQ(Angle(345).HoursHa(), -1);
48 }
49 
50 TEST(AngleTest, Logic)
51 {
52  Angle a = -60;
53  EXPECT_EQ(a.HoursHa(), -4);
54 
55  EXPECT_TRUE(a == Angle(-60));
56  EXPECT_FALSE(a == Angle(60));
57  EXPECT_TRUE(a != Angle(-61));
58  EXPECT_FALSE(a != Angle(-60));
59  EXPECT_TRUE(a < Angle(119));
60  EXPECT_TRUE(a > Angle(121));
61  EXPECT_TRUE(Angle(350) < Angle(10));
62  EXPECT_FALSE(Angle(351) > Angle(11));
63 }
64 
65 TEST(AngleTest, Arithmetic)
66 {
67  Angle a = -60;
68  Angle b = 60;
69  EXPECT_EQ((a + b).Degrees(), 0);
70  EXPECT_EQ((a - b).Degrees(), -120);
71  EXPECT_EQ((b - a).Degrees(), 120);
72 
73  a += 10;
74  EXPECT_EQ(a.Degrees(), -50);
75  a += Angle(10);
76  EXPECT_EQ(a.Degrees(), -40);
77 
78  EXPECT_EQ((b * 0.5).Degrees(), 30);
79  EXPECT_EQ(-a.Degrees(), 40);
80 
81 }
82 
83 // Vector tests
84 
85 TEST(VectorTest, Constructors)
86 {
87  Vector v = Vector();
88  EXPECT_EQ(v.l(), 0);
89  EXPECT_EQ(v.m(), 0);
90  EXPECT_EQ(v.n(), 0);
91 
92  v = Vector(2, 3, 6);
93  EXPECT_EQ(v.l(), 2. / 7);
94  EXPECT_EQ(v.m(), 3. / 7);
95  EXPECT_EQ(v.n(), 6. / 7);
96 
97  v = Vector(Angle(90), Angle(45));
98  EXPECT_NEAR(v.l(), 0, 0.00001);
99  EXPECT_NEAR(v.m(), 0.707107, 0.00001);
100  EXPECT_NEAR(v.n(), 0.707107, 0.00001);
101 }
102 
103 TEST(VectorTest, PriSec)
104 {
105  Vector v = Vector(Angle(90), Angle(45));
106  EXPECT_NEAR(v.primary().Degrees(), 90, 0.00001);
107  EXPECT_NEAR(v.secondary().Degrees(), 45, 0.00001);
108  EXPECT_EQ(v.lengthSquared(), 1.0);
109 }
110 
111 TEST(VectorTest, length)
112 {
113  Vector v(1, 4, 8);
114  EXPECT_DOUBLE_EQ(v.lengthSquared(), 1);
115  EXPECT_DOUBLE_EQ(v.length(), 1);
116  v.normalise();
117  EXPECT_DOUBLE_EQ(v.length(), 1);
118  EXPECT_DOUBLE_EQ(v.l(), 1. / 9.);
119  EXPECT_DOUBLE_EQ(v.m(), 4. / 9.);
120  EXPECT_DOUBLE_EQ(v.n(), 8. / 9.);
121 }
122 
123 TEST(VectorTest, rotateX)
124 {
125  Vector v = Vector(Angle(90), Angle(45));
126  Vector vr = v.rotateX(Angle(45));
127  EXPECT_NEAR(vr.primary().Degrees(), 90, 0.00001);
128  EXPECT_NEAR(vr.secondary().Degrees(), 0, 0.00001);
129  v = vr.rotateX(Angle(-45));
130  EXPECT_NEAR(v.primary().Degrees(), 90, 0.00001);
131  EXPECT_NEAR(v.secondary().Degrees(), 45, 0.00001);
132 }
133 
134 TEST(VectorTest, rotateY)
135 {
136  Vector v = Vector(Angle(90), Angle(45));
137  Vector vr = v.rotateY(Angle(45));
138  EXPECT_NEAR(vr.primary().Degrees(), 125.26439, 0.00001);
139  EXPECT_NEAR(vr.secondary().Degrees(), 30, 0.00001);
140  v = vr.rotateY(Angle(-45));
141  EXPECT_NEAR(v.primary().Degrees(), 90, 0.00001);
142  EXPECT_NEAR(v.secondary().Degrees(), 45, 0.00001);
143 }
144 
145 TEST(VectorTest, rotateZ)
146 {
147  Vector v = Vector(Angle(90), Angle(45));
148  Vector vr = v.rotateZ(Angle(45));
149  EXPECT_NEAR(vr.primary().Degrees(), 45, 0.00001);
150  EXPECT_NEAR(vr.secondary().Degrees(), 45, 0.00001);
151  v = vr.rotateZ(Angle(-45));
152  EXPECT_NEAR(v.primary().Degrees(), 90, 0.00001);
153  EXPECT_NEAR(v.secondary().Degrees(), 45, 0.00001);
154 }
155 
156 // Alignment tests
157 // the tuple contains:
158 // Test Ha, Ra, primary, azimuth angle
159 // Test Dec, altitude, secondary angle
160 // Expected Ha, Ra, primary, azimuth angle
161 // Expected Dec, altitude, secondary angle
162 
163 class AlignmentTest : public ::testing::Test
164 {
165  protected:
166  Alignment alignment;
167  AlignmentTest()
168  {
169  alignment.latitude = Angle(51.6);
170  alignment.longitude = Angle(-0.73);
171  }
172 };
173 
174 TEST_F(AlignmentTest, Create)
175 {
176  EXPECT_EQ(alignment.latitude.Degrees(), 51.6);
177  EXPECT_EQ(alignment.longitude.Degrees(), -0.73);
178 
179  EXPECT_EQ(alignment.mountType, Alignment::MOUNT_TYPE::EQ_FORK);
180 }
181 
182 TEST_F(AlignmentTest, Errors)
183 {
184  EXPECT_EQ(alignment.ih(), 0);
185  EXPECT_EQ(alignment.id(), 0);
186  EXPECT_EQ(alignment.np(), 0);
187  EXPECT_EQ(alignment.ch(), 0);
188  EXPECT_EQ(alignment.ma(), 0);
189  EXPECT_EQ(alignment.me(), 0);
190  alignment.setCorrections(1, 2, 3, 4, 5, 6);
191  EXPECT_EQ(alignment.ih(), 1);
192  EXPECT_EQ(alignment.id(), 2);
193  EXPECT_EQ(alignment.np(), 4);
194  EXPECT_EQ(alignment.ch(), 3);
195  EXPECT_EQ(alignment.ma(), 5);
196  EXPECT_EQ(alignment.me(), 6);
197 }
198 
199 TEST_F(AlignmentTest, instrumentToObservedME1)
200 {
201  Angle oHa, oDec;
202 
203  alignment.setCorrections(0, 0, 0, 0, 0, 1); // ME 1
204 
205  // looking NS
206  alignment.instrumentToObserved(Angle(0), Angle(0), &oHa, &oDec);
207  EXPECT_EQ(oHa.Degrees(), 0);
208  EXPECT_EQ(oDec.Degrees(), 1);
209 
210  // looking EW
211  alignment.instrumentToObserved(Angle(90), Angle(0), &oHa, &oDec);
212  EXPECT_EQ(oHa.Degrees(), 90);
213  EXPECT_NEAR(oDec.Degrees(), 0, 1e10);
214 
215  // on meridian, dec 80
216  alignment.instrumentToObserved(Angle(0), Angle(80), &oHa, &oDec);
217  EXPECT_EQ(oHa.Degrees(), 0);
218  EXPECT_FLOAT_EQ(oDec.Degrees(), 81);
219 
220  // looking at pole
221  alignment.instrumentToObserved(Angle(0), Angle(90), &oHa, &oDec);
222  EXPECT_FLOAT_EQ(oHa.HoursHa(), 12);
223  EXPECT_FLOAT_EQ(oDec.Degrees(), 89);
224 
225  // 89 dec, expect move to pole
226  alignment.instrumentToObserved(Angle(0), Angle(89), &oHa, &oDec);
227  //EXPECT_FLOAT_EQ(oHa.HoursHa(), 12); // 0 or 12, similar case as observedToInstrumentME1
228  EXPECT_FLOAT_EQ(oDec.Degrees(), 90);
229 
230  // 1 deg W of pole
231  alignment.instrumentToObserved(Angle(90), Angle(89), &oHa, &oDec);
232  EXPECT_NEAR(oHa.HoursHa(), 8.9997, 0.0001);
233  EXPECT_FLOAT_EQ(oDec.Degrees(), 88.5858);
234 }
235 
236 TEST_F(AlignmentTest, observedToInstrumentME1)
237 {
238  Angle oHa, oDec;
239 
240  alignment.setCorrections(0, 0, 0, 0, 0, 1); // ME 1
241 
242  // looking NS
243  alignment.observedToInstrument(Angle(0), Angle(0), &oHa, &oDec);
244  EXPECT_EQ(oHa.Degrees(), 0);
245  EXPECT_EQ(oDec.Degrees(), -1);
246 
247  // looking EW
248  alignment.instrumentToObserved(Angle(-90), Angle(0), &oHa, &oDec);
249  EXPECT_EQ(oHa.Degrees(), -90);
250  EXPECT_NEAR(oDec.Degrees(), 0, 1e10);
251 
252  // on meridian, dec 80
253  alignment.observedToInstrument(Angle(0), Angle(80), &oHa, &oDec);
254  EXPECT_EQ(oHa.Degrees(), 0);
255  EXPECT_FLOAT_EQ(oDec.Degrees(), 79);
256 
257  // looking at pole
258  alignment.observedToInstrument(Angle(90), Angle(90), &oHa, &oDec);
259  EXPECT_NEAR(oHa.HoursHa(), 0, 0.0001);
260  EXPECT_FLOAT_EQ(oDec.Degrees(), 89);
261 
262  // 89 dec, expect move to pole
263  alignment.observedToInstrument(Angle(180), Angle(89), &oHa, &oDec);
264  //EXPECT_FLOAT_EQ(oHa.HoursHa(), 0);
265  EXPECT_FLOAT_EQ(oDec.Degrees(), 90);
266 
267  // 1 deg E of pole
268  alignment.observedToInstrument(Angle(-90), Angle(89), &oHa, &oDec);
269  EXPECT_NEAR(oHa.HoursHa(), -3.0003, 0.00001);
270  EXPECT_FLOAT_EQ(oDec.Degrees(), 88.5858);
271 }
272 
273 
274 TEST_F(AlignmentTest, observedToInstrumentMEn1)
275 {
276  Angle oHa, oDec;
277 
278  alignment.setCorrections(0, 0, 0, 0, 0, -1); // ME -1
279 
280  // looking NS
281  alignment.observedToInstrument(Angle(0), Angle(0), &oHa, &oDec);
282  EXPECT_EQ(oHa.Degrees(), 0);
283  EXPECT_EQ(oDec.Degrees(), 1);
284 
285  // looking EW
286  alignment.instrumentToObserved(Angle(-90), Angle(0), &oHa, &oDec);
287  EXPECT_EQ(oHa.Degrees(), -90);
288  EXPECT_NEAR(oDec.Degrees(), 0, 1e10);
289 
290  // on meridian, dec 80
291  alignment.observedToInstrument(Angle(0), Angle(80), &oHa, &oDec);
292  EXPECT_EQ(oHa.Degrees(), 0);
293  EXPECT_FLOAT_EQ(oDec.Degrees(), 81);
294 
295  // looking at pole
296  alignment.observedToInstrument(Angle(90), Angle(90), &oHa, &oDec);
297  EXPECT_NEAR(oHa.HoursHa(), 12, 0.0001);
298  EXPECT_FLOAT_EQ(oDec.Degrees(), 89);
299 
300  // 89 dec, expect move to pole
301  alignment.observedToInstrument(Angle(0), Angle(89), &oHa, &oDec);
302  //EXPECT_FLOAT_EQ(oHa.HoursHa(), 0);
303  EXPECT_FLOAT_EQ(oDec.Degrees(), 90);
304 
305  // 1 deg E of pole
306  alignment.observedToInstrument(Angle(-90), Angle(89), &oHa, &oDec);
307  EXPECT_NEAR(oHa.HoursHa(), -8.9997, 0.00001);
308  EXPECT_FLOAT_EQ(oDec.Degrees(), 88.5858);
309 }
310 
311 TEST_F(AlignmentTest, instrumentToObservedMA1)
312 {
313  Angle oHa, oDec;
314 
315  alignment.setCorrections(0, 0, 0, 0, 1, 0); // MA 1
316 
317  // looking NS
318  alignment.instrumentToObserved(Angle(0), Angle(0), &oHa, &oDec);
319  EXPECT_EQ(oHa.Degrees(), 0);
320  EXPECT_EQ(oDec.Degrees(), 0);
321 
322  // looking WE
323  alignment.instrumentToObserved(Angle(-90), Angle(0), &oHa, &oDec);
324  EXPECT_EQ(oHa.Degrees(), -90);
325  EXPECT_EQ(oDec.Degrees(), 1);
326 
327  // W, dec 80
328  alignment.instrumentToObserved(Angle(90), Angle(80), &oHa, &oDec);
329  EXPECT_EQ(oHa.Degrees(), 90);
330  EXPECT_FLOAT_EQ(oDec.Degrees(), 79);
331 
332  // looking at pole
333  alignment.instrumentToObserved(Angle(0), Angle(90), &oHa, &oDec);
334  EXPECT_FLOAT_EQ(oHa.HoursHa(), 6);
335  EXPECT_FLOAT_EQ(oDec.Degrees(), 89);
336 
337  // 89 dec, expect move to pole
338  alignment.instrumentToObserved(Angle(-90), Angle(89), &oHa, &oDec);
339  //EXPECT_FLOAT_EQ(oHa.HoursHa(), -6);
340  EXPECT_FLOAT_EQ(oDec.Degrees(), 90);
341 
342  // 1 deg N of pole
343  alignment.instrumentToObserved(Angle(180), Angle(89), &oHa, &oDec);
344  EXPECT_NEAR(oHa.HoursHa(), 9.0003, 0.0001);
345  EXPECT_FLOAT_EQ(oDec.Degrees(), 88.5858);
346 }
347 
348 
349 TEST_F(AlignmentTest, instrumentToObservedMAm1)
350 {
351  Angle oHa, oDec;
352 
353  alignment.setCorrections(0, 0, 0, 0, -1, 0); // MA -1
354 
355  // looking NS
356  alignment.instrumentToObserved(Angle(0), Angle(0), &oHa, &oDec);
357  EXPECT_EQ(oHa.Degrees(), 0);
358  EXPECT_EQ(oDec.Degrees(), 0);
359 
360  // looking WE
361  alignment.instrumentToObserved(Angle(-90), Angle(0), &oHa, &oDec);
362  EXPECT_EQ(oHa.Degrees(), -90);
363  EXPECT_EQ(oDec.Degrees(), -1);
364 
365  // W, dec 80
366  alignment.instrumentToObserved(Angle(90), Angle(80), &oHa, &oDec);
367  EXPECT_EQ(oHa.Degrees(), 90);
368  EXPECT_FLOAT_EQ(oDec.Degrees(), 81);
369 
370  // looking at pole
371  alignment.instrumentToObserved(Angle(0), Angle(90), &oHa, &oDec);
372  EXPECT_FLOAT_EQ(oHa.HoursHa(), -6);
373  EXPECT_FLOAT_EQ(oDec.Degrees(), 89);
374 
375  // 89 dec, expect move to pole
376  alignment.instrumentToObserved(Angle(90), Angle(89), &oHa, &oDec);
377  //EXPECT_FLOAT_EQ(oHa.HoursHa(), -6);
378  EXPECT_FLOAT_EQ(oDec.Degrees(), 90);
379 
380  // 1 deg S of pole
381  alignment.instrumentToObserved(Angle(0), Angle(89), &oHa, &oDec);
382  EXPECT_NEAR(oHa.HoursHa(), -2.9997, 0.0001);
383  EXPECT_FLOAT_EQ(oDec.Degrees(), 88.5858);
384 }
385 
386 TEST_F(AlignmentTest, observedToInstrumentMA1)
387 {
388  Angle iHa, iDec;
389 
390  alignment.setCorrections(0, 0, 0, 0, 1, 0); // MA 1
391 
392  // looking NS
393  alignment.observedToInstrument(Angle(0), Angle(0), &iHa, &iDec);
394  EXPECT_EQ(iHa.Degrees(), 0);
395  EXPECT_EQ(iDec.Degrees(), 0);
396 
397  // looking EW
398  alignment.observedToInstrument(Angle(90), Angle(0), &iHa, &iDec);
399  EXPECT_EQ(iHa.Degrees(), 90);
400  EXPECT_EQ(iDec.Degrees(), 1);
401 
402  // E, dec 80
403  alignment.observedToInstrument(Angle(-90), Angle(80), &iHa, &iDec);
404  EXPECT_EQ(iHa.Degrees(), -90);
405  EXPECT_FLOAT_EQ(iDec.Degrees(), 79);
406 
407  // looking at pole
408  alignment.observedToInstrument(Angle(90), Angle(90), &iHa, &iDec);
409  EXPECT_NEAR(iHa.HoursHa(), -6, 0.0001);
410  EXPECT_FLOAT_EQ(iDec.Degrees(), 89);
411 
412  // 1 deg S of pole
413  alignment.observedToInstrument(Angle(0), Angle(89), &iHa, &iDec);
414  EXPECT_NEAR(iHa.HoursHa(), -2.9997, 0.00001);
415  EXPECT_FLOAT_EQ(iDec.Degrees(), 88.5858);
416 }
417 
418 
419 TEST_F(AlignmentTest, instrumentToObservedCH1)
420 {
421  Angle oHa, oDec;
422 
423  alignment.setCorrections(0, 0, 1, 0, 0, 0); // CH 1
424 
425  // looking NS
426  alignment.instrumentToObserved(Angle(0), Angle(0), &oHa, &oDec);
427  EXPECT_EQ(oHa.Degrees(), 1);
428  EXPECT_EQ(oDec.Degrees(), 0);
429 
430  // looking WE
431  alignment.instrumentToObserved(Angle(-90), Angle(0), &oHa, &oDec);
432  EXPECT_EQ(oHa.Degrees(), -89);
433  EXPECT_EQ(oDec.Degrees(), 0);
434 
435  // W, dec 60
436  alignment.instrumentToObserved(Angle(90), Angle(60), &oHa, &oDec);
437  EXPECT_EQ(oHa.Degrees(), 92);
438  EXPECT_FLOAT_EQ(oDec.Degrees(), 60);
439 
440  // looking at pole
441  alignment.instrumentToObserved(Angle(0), Angle(90), &oHa, &oDec);
442  //EXPECT_FLOAT_EQ(oHa.HoursHa(), 6);
443  EXPECT_FLOAT_EQ(oDec.Degrees(), 90);
444 
445  // 89 dec
446  alignment.instrumentToObserved(Angle(-90), Angle(89), &oHa, &oDec);
447  EXPECT_NEAR(oHa.HoursHa(), -2.180087, 0.0001);
448  EXPECT_FLOAT_EQ(oDec.Degrees(), 89);
449 
450  // 1 deg N of pole
451  alignment.instrumentToObserved(Angle(180), Angle(89), &oHa, &oDec);
452  EXPECT_NEAR(oHa.HoursHa(), -8.180087, 0.0001);
453  EXPECT_FLOAT_EQ(oDec.Degrees(), 89);
454 }
455 
456 TEST_F(AlignmentTest, observedToInstrumentCH1)
457 {
458  Angle iHa, iDec;
459 
460  alignment.setCorrections(0, 0, 1, 0, 0, 0); // CH 1
461 
462  // looking NS
463  alignment.observedToInstrument(Angle(0), Angle(0), &iHa, &iDec);
464  EXPECT_EQ(iHa.Degrees(), -1);
465  EXPECT_EQ(iDec.Degrees(), 0);
466 
467  // looking EW
468  alignment.observedToInstrument(Angle(90), Angle(0), &iHa, &iDec);
469  EXPECT_EQ(iHa.Degrees(), 89);
470  EXPECT_EQ(iDec.Degrees(), 0);
471 
472  // E, dec 60
473  alignment.observedToInstrument(Angle(-90), Angle(60), &iHa, &iDec);
474  EXPECT_EQ(iHa.Degrees(), -92);
475  EXPECT_FLOAT_EQ(iDec.Degrees(), 60);
476 
477  // looking at pole
478  alignment.observedToInstrument(Angle(90), Angle(90), &iHa, &iDec);
479  //EXPECT_NEAR(iHa.HoursHa(), -6, 0.0001);
480  EXPECT_FLOAT_EQ(iDec.Degrees(), 90);
481 
482  // 1 deg S of pole
483  alignment.observedToInstrument(Angle(0), Angle(89), &iHa, &iDec);
484  EXPECT_NEAR(iHa.HoursHa(), -3.81991, 0.00001);
485  EXPECT_FLOAT_EQ(iDec.Degrees(), 89);
486 }
487 
488 TEST_F(AlignmentTest, roundTripMAME1)
489 {
490  Angle oHa, oDec;
491  Angle iHa, iDec;
492 
493  alignment.setCorrections(0, 0, 0, 0, 1, 1); // MA 1, ME 1
494 
495  // looking NS
496  alignment.instrumentToObserved(Angle(0), Angle(0), &oHa, &oDec);
497  alignment.observedToInstrument(oHa, oDec, &iHa, &iDec);
498  EXPECT_NEAR(iHa.Degrees(), 0, 0.00001);
499  EXPECT_NEAR(iDec.Degrees(), 0, 0.00001);
500 
501  // looking EW
502  alignment.instrumentToObserved(Angle(90), Angle(0), &oHa, &oDec);
503  alignment.observedToInstrument(oHa, oDec, &iHa, &iDec);
504  EXPECT_NEAR(iHa.Degrees(), 90, 0.00001);
505  EXPECT_NEAR(iDec.Degrees(), 0, 0.00001);
506 
507  // on meridian, dec 80
508  alignment.instrumentToObserved(Angle(0), Angle(80), &oHa, &oDec);
509  alignment.observedToInstrument(oHa, oDec, &iHa, &iDec);
510  EXPECT_NEAR(iHa.Degrees(), 0, 0.00001);
511  EXPECT_NEAR(iDec.Degrees(), 80, 0.00001);
512 
513  // E, dec 80
514  alignment.instrumentToObserved(Angle(-90), Angle(80), &oHa, &oDec);
515  alignment.observedToInstrument(oHa, oDec, &iHa, &iDec);
516  EXPECT_NEAR(iHa.Degrees(), -90, 0.00001);
517  EXPECT_NEAR(iDec.Degrees(), 80, 0.00001);
518 
519  // looking at pole
520  alignment.instrumentToObserved(Angle(0), Angle(90), &oHa, &oDec);
521  alignment.observedToInstrument(oHa, oDec, &iHa, &iDec);
522  //EXPECT_NEAR(iHa.Degrees(), 0, 0.0001);
523  EXPECT_NEAR(iDec.Degrees(), 90, 0.00001);
524 
525  // 89 dec, expect move to pole
526  alignment.instrumentToObserved(Angle(0), Angle(89), &oHa, &oDec);
527  alignment.observedToInstrument(oHa, oDec, &iHa, &iDec);
528  EXPECT_NEAR(iHa.Degrees(), 0, 0.00001);
529  EXPECT_NEAR(iDec.Degrees(), 89, 0.00001);
530 
531  // 1 deg W of pole
532  alignment.instrumentToObserved(Angle(90), Angle(89), &oHa, &oDec);
533  alignment.observedToInstrument(oHa, oDec, &iHa, &iDec);
534  EXPECT_NEAR(iHa.Degrees(), 90, 0.00001);
535  EXPECT_NEAR(iDec.Degrees(), 89, 0.00001);
536 
537  // 1 deg S of pole
538  alignment.instrumentToObserved(Angle(0), Angle(89), &oHa, &oDec);
539  alignment.observedToInstrument(oHa, oDec, &iHa, &iDec);
540  EXPECT_NEAR(iHa.Degrees(), 0, 0.00001);
541  EXPECT_NEAR(iDec.Degrees(), 89, 0.00001);
542 }
543 
544 /*
545 class AlignmentParametersTest :public ::testing::TestWithParam<std::tuple<double, double, double, double>>
546 {
547 protected:
548  Alignment alignment;
549  AlignmentParametersTest()
550  {
551  alignment.latitude = Angle(51.6);
552  alignment.longitude = Angle(-0.73);
553  }
554 };
555 
556 INSTANTIATE_TEST_SUITE_P
557 (
558  ZeroErrors,
559  AlignmentParametersTest,
560  ::testing::Values
561  (
562  // test Ha, Dec, expected Ha, Dec - all in degrees
563  std::make_tuple(0, 0, 0, 0),
564  std::make_tuple(0, 30, 0, 30),
565  std::make_tuple(-90, 0, -90, 0),
566  std::make_tuple(90, 30, 90, 30),
567  std::make_tuple(-179, 60, -179, 60),
568  std::make_tuple(-180, 90, 180, 90)
569  )
570 );
571 
572 TEST_P(AlignmentParametersTest, observed2Instrument)
573 {
574  Angle iHa, iDec;
575 
576  double testHa = std::get<0>(GetParam());
577  double testDec = std::get<1>(GetParam());
578  double expectedHa = std::get<2>(GetParam());
579  double expectedDec = std::get<3>(GetParam());
580 
581  alignment.observedToInstrument(Angle(testHa), Angle(testDec), &iHa, &iDec);
582  EXPECT_EQ(iHa.Degrees(), expectedHa);
583  EXPECT_EQ(iDec.Degrees(), expectedDec);
584 }
585 
586 TEST_P(AlignmentParametersTest, InstrumentToObserved)
587 {
588  Angle iHa, iDec;
589 
590  double testHa = std::get<0>(GetParam());
591  double testDec = std::get<1>(GetParam());
592  double expectedHa = std::get<2>(GetParam());
593  double expectedDec = std::get<3>(GetParam());
594 
595  alignment.instrumentToObserved(Angle(testHa), Angle(testDec), &iHa, &iDec);
596  EXPECT_FLOAT_EQ(iHa.Degrees(), expectedHa);
597  EXPECT_FLOAT_EQ(iDec.Degrees(), expectedDec);
598 }
599 
600 INSTANTIATE_TEST_SUITE_P
601 (
602  TestME1,
603  AlignmentParametersTest,
604  ::testing::Values
605  (
606  // test Ha, Dec, expected Ha, Dec - all in degrees
607  std::make_tuple(0, 0, 0, 0),
608  std::make_tuple(0, 30, 0, 30),
609  std::make_tuple(-90, 0, -90, 0),
610  std::make_tuple(90, 30, 90, 30),
611  std::make_tuple(-179, 60, -179, 60),
612  std::make_tuple(-180, 90, 180, 90)
613  )
614 );
615 */
616 
617 int main(int argc, char **argv)
618 {
619  INDI::Logger::getInstance().configure("", INDI::Logger::file_off,
620  INDI::Logger::DBG_ERROR, INDI::Logger::DBG_ERROR);
621 
622  ::testing::InitGoogleTest(&argc, argv);
623  ::testing::InitGoogleMock(&argc, argv);
624  return RUN_ALL_TESTS();
625 }
626 
627 
Alignment
The Alignment class This converts between the mount axis angles and the sky hour angle and declinatio...
Definition: scopesim_helper.h:403
Angle
The Angle class This class implements an angle type. This holds an angle that is always in the range ...
Definition: scopesim_helper.h:51
Angle::radians
double radians()
radians
Definition: scopesim_helper.cpp:48
Angle::Hours
double Hours()
Hours.
Definition: scopesim_helper.h:111
Angle::HoursHa
double HoursHa()
HoursHa.
Definition: scopesim_helper.h:122
Angle::Degrees
double Degrees()
Degrees.
Definition: scopesim_helper.h:93
Vector
The Vector class This implements the Directional Cosine used by Taki in his Matrix method....
Definition: scopesim_helper.h:566
Vector::n
double n()
Definition: scopesim_helper.h:642
Vector::rotateY
Vector rotateY(Angle angle)
rotateY rotates this vector through angle about the Y axis
Definition: scopesim_helper.cpp:533
Vector::rotateX
Vector rotateX(Angle angle)
rotateX rotates this vector through angle about the X axis
Definition: scopesim_helper.cpp:526
Vector::lengthSquared
double lengthSquared()
Definition: scopesim_helper.h:592
Vector::length
double length()
Definition: scopesim_helper.h:597
Vector::rotateZ
Vector rotateZ(Angle angle)
rotateZ rotates this vector through angle about the Z axis
Definition: scopesim_helper.cpp:540
Vector::normalise
void normalise()
Definition: scopesim_helper.cpp:504
Vector::secondary
Angle secondary()
secondary returns the secondary angle (dec, altitude) from this vector
Definition: scopesim_helper.cpp:519
Vector::l
double l()
Definition: scopesim_helper.h:634
Vector::primary
Angle primary()
primary returns the primary angle (Ra, Ha, Azimuth) from this vector
Definition: scopesim_helper.cpp:512
Vector::m
double m()
Definition: scopesim_helper.h:638
indidevapi.h
Interface to the reference INDI C API device implementation on the Device Driver side.
Errors
Errors
Definition: lx200_OnStep.h:155
INDI::AlignmentSubsystem::Create
DummyMathPlugin * Create()
Definition: DummyMathPlugin.cpp:13
scopesim_helper.h
INDI::Logger::file_off
static const loggerConf file_off
Definition: indilogger.h:219
INDI::Logger::configure
void configure(const std::string &outputFile, const loggerConf configuration, const int fileVerbosityLevel, const int screenVerbosityLevel)
Method to configure the logger. Called by the DEBUG_CONF() macro. To make implementation easier,...
Definition: indilogger.cpp:283
INDI::Logger::getInstance
static Logger & getInstance()
Method to get a reference to the object (i.e., Singleton) It is a static method.
Definition: indilogger.cpp:339
telescope_simulator.h
main
int main(int argc, char **argv)
Definition: test_scopesim_helper.cpp:617
TEST
TEST(AngleTest, CreateAngle)
Definition: test_scopesim_helper.cpp:21
TEST_F
TEST_F(AlignmentTest, Create)
Definition: test_scopesim_helper.cpp:174
Generated on Sat May 13 2023 14:24:24 for Instrument Neutral Distributed Interface INDI by doxygen 1.9.1