Instrument Neutral Distributed Interface INDI 2.2.5
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
17using ::testing::_;
18using ::testing::StrEq;
19
20// Angle tests
21TEST(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
50TEST(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
65TEST(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
85TEST(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
103TEST(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
111TEST(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
123TEST(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
134TEST(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
145TEST(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
163class 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
174TEST_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
182TEST_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
199TEST_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
236TEST_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
274TEST_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
311TEST_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
349TEST_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
386TEST_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
419TEST_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
456TEST_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
488TEST_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/*
545class AlignmentParametersTest :public ::testing::TestWithParam<std::tuple<double, double, double, double>>
546{
547protected:
548 Alignment alignment;
549 AlignmentParametersTest()
550 {
551 alignment.latitude = Angle(51.6);
552 alignment.longitude = Angle(-0.73);
553 }
554};
555
556INSTANTIATE_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
572TEST_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
586TEST_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
600INSTANTIATE_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
617int 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
Create
INDI::AlignmentSubsystem::BuiltInMathPlugin * Create()
Definition BuiltInMathPlugin.cpp:97
Alignment
The Alignment class This converts between the mount axis angles and the sky hour angle and declinatio...
Definition scopesim_helper.h:410
Angle
The Angle class This class implements an angle type. This holds an angle that is always in the range ...
Definition scopesim_helper.h:53
Angle::radians
double radians()
radians
Definition scopesim_helper.cpp:54
Angle::Hours
double Hours()
Hours.
Definition scopesim_helper.h:113
Angle::HoursHa
double HoursHa()
HoursHa.
Definition scopesim_helper.h:124
Angle::Degrees
double Degrees()
Degrees.
Definition scopesim_helper.h:95
Vector
The Vector class This implements the Directional Cosine used by Taki in his Matrix method....
Definition scopesim_helper.h:591
Vector::n
double n()
Definition scopesim_helper.h:667
Vector::rotateY
Vector rotateY(Angle angle)
rotateY rotates this vector through angle about the Y axis
Definition scopesim_helper.cpp:634
Vector::rotateX
Vector rotateX(Angle angle)
rotateX rotates this vector through angle about the X axis
Definition scopesim_helper.cpp:627
Vector::lengthSquared
double lengthSquared()
Definition scopesim_helper.h:617
Vector::length
double length()
Definition scopesim_helper.h:622
Vector::rotateZ
Vector rotateZ(Angle angle)
rotateZ rotates this vector through angle about the Z axis
Definition scopesim_helper.cpp:641
Vector::normalise
void normalise()
Definition scopesim_helper.cpp:605
Vector::secondary
Angle secondary()
secondary returns the secondary angle (dec, altitude) from this vector
Definition scopesim_helper.cpp:620
Vector::l
double l()
Definition scopesim_helper.h:659
Vector::primary
Angle primary()
primary returns the primary angle (Ra, Ha, Azimuth) from this vector
Definition scopesim_helper.cpp:613
Vector::m
double m()
Definition scopesim_helper.h:663
M_PI
#define M_PI
Definition dsp.h:52
main
int main()
Definition fakedriver.cpp:25
indidevapi.h
Interface to the reference INDI C API device implementation on the Device Driver side.
Errors
Errors
Definition lx200_OnStep.h:169
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
TEST
TEST(AngleTest, CreateAngle)
Definition test_scopesim_helper.cpp:21
TEST_F
TEST_F(AlignmentTest, Create)
Definition test_scopesim_helper.cpp:174
Generated on Thu Oct 22 2026 14:46:49 for Instrument Neutral Distributed Interface INDI by doxygen 1.9.8