HelmertTransformer_T.cpp
Go to the documentation of this file.
1 //==============================================================================
2 //
3 // This file is part of GNSSTk, the ARL:UT GNSS Toolkit.
4 //
5 // The GNSSTk is free software; you can redistribute it and/or modify
6 // it under the terms of the GNU Lesser General Public License as published
7 // by the Free Software Foundation; either version 3.0 of the License, or
8 // any later version.
9 //
10 // The GNSSTk is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with GNSSTk; if not, write to the Free Software Foundation,
17 // Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
18 //
19 // This software was developed by Applied Research Laboratories at the
20 // University of Texas at Austin.
21 // Copyright 2004-2022, The Board of Regents of The University of Texas System
22 //
23 //==============================================================================
24 
25 //==============================================================================
26 //
27 // This software was developed by Applied Research Laboratories at the
28 // University of Texas at Austin, under contract to an agency or agencies
29 // within the U.S. Department of Defense. The U.S. Government retains all
30 // rights to use, duplicate, distribute, disclose, or release this software.
31 //
32 // Pursuant to DoD Directive 523024
33 //
34 // DISTRIBUTION STATEMENT A: This software has been approved for public
35 // release, distribution is unlimited.
36 //
37 //==============================================================================
38 
39 #include "TestUtil.hpp"
40 #include "HelmertTransformer.hpp"
41 #include "YDSTime.hpp"
42 
44 class TestClass : public gnsstk::HelmertTransformer
45 {
46 public:
47  using gnsstk::HelmertTransformer::HelmertTransformer;
48  double getrx() const { return rotation(2,1); }
49  double getry() const { return rotation(0,2); }
50  double getrz() const { return rotation(1,0); }
51  double gettx() const { return translation(0); }
52  double getty() const { return translation(1); }
53  double gettz() const { return translation(2); }
54  double getscale() const { return scale; }
55  std::string getdescription() const { return description; }
56 };
57 
58 
59 class HelmertTransformer_T
60 {
61 public:
62  HelmertTransformer_T();
63  unsigned constructorTest();
64  unsigned transformPositionTest();
65  unsigned transformVectorTest();
66  unsigned transformTripleTest();
67  unsigned transformXvtTest();
68  unsigned transformdoubleTest();
69 
70  gnsstk::RefFrame initialRF;
71  gnsstk::RefFrame finalRF;
72  gnsstk::HelmertTransformer uut1, uut2;
74  std::vector<double> p1, x1, p2, x2;
75 };
76 
77 
78 HelmertTransformer_T ::
79 HelmertTransformer_T()
80  : initialRF(gnsstk::RefFrameSys::WGS84,
81  gnsstk::YDSTime(2020,123,456,gnsstk::TimeSystem::UTC)),
82  finalRF(gnsstk::RefFrameSys::CGCS2000,
83  gnsstk::YDSTime(1994,1,0,gnsstk::TimeSystem::UTC)),
84  uut1(initialRF, finalRF, 0, 0, 0, 10, 10, 10, 1, "hi there",
85  gnsstk::YDSTime(2020,123,456,gnsstk::TimeSystem::UTC)),
86  // https://d28rz98at9flks.cloudfront.net/71433/71433.pdf
87  uut2(initialRF, finalRF, -24.1665*gnsstk::DEG_PER_MAS,
88  -20.9515*gnsstk::DEG_PER_MAS, -21.3961*gnsstk::DEG_PER_MAS,
89  -42.7e-3, -17.06e-3, 28.81e-3, 11.474*gnsstk::PPB, "step 2",
90  gnsstk::YDSTime(1994, 1, 0,gnsstk::TimeSystem::UTC)),
91  p1({150, 150, 150}),
92  x1({310, 310, 310}), // 100% scale, 10m translation
93  p2({-4052052.3678, 4212836.0411, -2545105.1089}),
94  x2({-4052051.7615, 4212836.1945, -2545106.0145})
95 {
96 }
97 
98 
99 unsigned HelmertTransformer_T ::
100 constructorTest()
101 {
102  TUDEF("HelmertTransformer", "HelmertTransformer");
103  TestClass uut1;
104  gnsstk::RefFrame exp;
105  TUASSERTE(gnsstk::RefFrame, exp, uut1.getFromFrame());
106  TUASSERTE(gnsstk::RefFrame, exp, uut1.getToFrame());
107  TUASSERTE(int, 1, std::isnan(uut1.getscale()));
108 
109  TestClass uut2(gnsstk::RefFrame(gnsstk::RefFrameRlz::PZ90Y2007),
110  gnsstk::RefFrame(gnsstk::RefFrameRlz::WGS84G1150),
111  1e-4, 2e-4, 3e-4, 4, 5, 6, 7, "hi there",
112  gnsstk::YDSTime(2020,123,456,gnsstk::TimeSystem::UTC));
113  TUASSERTE(gnsstk::RefFrame,
114  gnsstk::RefFrame(gnsstk::RefFrameRlz::PZ90Y2007),
115  uut2.getFromFrame());
116  TUASSERTE(gnsstk::RefFrame,
117  gnsstk::RefFrame(gnsstk::RefFrameRlz::WGS84G1150),
118  uut2.getToFrame());
119  TUASSERTFE(1e-4*gnsstk::DEG_TO_RAD, uut2.getrx());
120  TUASSERTFE(2e-4*gnsstk::DEG_TO_RAD, uut2.getry());
121  TUASSERTFE(3e-4*gnsstk::DEG_TO_RAD, uut2.getrz());
122  TUASSERTFE(4, uut2.gettx());
123  TUASSERTFE(5, uut2.getty());
124  TUASSERTFE(6, uut2.gettz());
125  TUASSERTFE(7, uut2.getscale());
126  TUASSERTE(std::string, "hi there", uut2.getdescription());
127  TUASSERTE(gnsstk::CommonTime,
128  gnsstk::YDSTime(2020,123,456,gnsstk::TimeSystem::UTC),
129  uut2.getEpoch());
130  TURETURN();
131 }
132 
133 
134 unsigned HelmertTransformer_T ::
135 transformPositionTest()
136 {
137  TUDEF("HelmertTransformer", "transform(Position)");
138 
139  gnsstk::Position pos1(&p1[0], gnsstk::Position::Cartesian, nullptr,
140  initialRF);
141  gnsstk::Position exp1(&x1[0], gnsstk::Position::Cartesian, nullptr,
142  finalRF);
143  gnsstk::Position out1;
144  out1.setReferenceFrame(finalRF);
145  TUASSERTE(bool, true, uut1.transform(pos1, out1));
146  TUASSERTFE(exp1.getX(), out1.getX());
147  TUASSERTFE(exp1.getY(), out1.getY());
148  TUASSERTFE(exp1.getZ(), out1.getZ());
149 
150  gnsstk::Position pos2(&p2[0], gnsstk::Position::Cartesian, nullptr,
151  initialRF);
152  gnsstk::Position exp2(&x2[0], gnsstk::Position::Cartesian, nullptr, finalRF);
153  gnsstk::Position out2;
154  out2.setReferenceFrame(finalRF);
155  // forward transform
156  TUASSERTE(bool, true, uut2.transform(pos2, out2));
157  TUASSERTFEPS(exp2.getX(), out2.getX(), 1e-4);
158  TUASSERTFEPS(exp2.getY(), out2.getY(), 1e-4);
159  TUASSERTFEPS(exp2.getZ(), out2.getZ(), 1e-4);
160  // reverse transform
161  out2.setReferenceFrame(initialRF);
162  TUASSERTE(bool, true, uut2.transform(exp2, out2));
163  TUASSERTFEPS(pos2.getX(), out2.getX(), 1e-4);
164  TUASSERTFEPS(pos2.getY(), out2.getY(), 1e-4);
165  TUASSERTFEPS(pos2.getZ(), out2.getZ(), 1e-4);
166 
167  TURETURN();
168 }
169 
170 
171 unsigned HelmertTransformer_T ::
172 transformVectorTest()
173 {
174  TUDEF("HelmertTransformer", "transform(Vector)");
175 
176  gnsstk::Vector<double> pos1({p1[0], p1[1], p1[2]});
177  gnsstk::Vector<double> exp1({x1[0], x1[1], x1[2]});
178  gnsstk::Vector<double> out1;
179  TUASSERTE(bool, true, uut1.transform(pos1, initialRF, out1));
180  TUASSERTFE(exp1[0], out1[0]);
181  TUASSERTFE(exp1[1], out1[1]);
182  TUASSERTFE(exp1[2], out1[2]);
183 
184  gnsstk::Vector<double> pos2({p2[0], p2[1], p2[2]});
185  gnsstk::Vector<double> exp2({x2[0], x2[1], x2[2]});
186  gnsstk::Vector<double> out2;
187  // forward transform
188  TUASSERTE(bool, true, uut2.transform(pos2, initialRF, out2));
189  TUASSERTFEPS(exp2[0], out2[0], 1e-4);
190  TUASSERTFEPS(exp2[1], out2[1], 1e-4);
191  TUASSERTFEPS(exp2[2], out2[2], 1e-4);
192  // reverse transform
193  TUASSERTE(bool, true, uut2.transform(exp2, finalRF, out2));
194  TUASSERTFEPS(pos2[0], out2[0], 1e-4);
195  TUASSERTFEPS(pos2[1], out2[1], 1e-4);
196  TUASSERTFEPS(pos2[2], out2[2], 1e-4);
197 
198  TURETURN();
199 }
200 
201 
202 unsigned HelmertTransformer_T ::
203 transformTripleTest()
204 {
205  TUDEF("HelmertTransformer", "transform(Triple)");
206 
207  gnsstk::Triple pos1({p1[0], p1[1], p1[2]});
208  gnsstk::Triple exp1({x1[0], x1[1], x1[2]});
209  gnsstk::Triple out1;
210  TUASSERTE(bool, true, uut1.transform(pos1, initialRF, out1));
211  TUASSERTFE(exp1[0], out1[0]);
212  TUASSERTFE(exp1[1], out1[1]);
213  TUASSERTFE(exp1[2], out1[2]);
214 
215  gnsstk::Triple pos2({p2[0], p2[1], p2[2]});
216  gnsstk::Triple exp2({x2[0], x2[1], x2[2]});
217  gnsstk::Triple out2;
218  // forward transform
219  TUASSERTE(bool, true, uut2.transform(pos2, initialRF, out2));
220  TUASSERTFEPS(exp2[0], out2[0], 1e-4);
221  TUASSERTFEPS(exp2[1], out2[1], 1e-4);
222  TUASSERTFEPS(exp2[2], out2[2], 1e-4);
223  // reverse transform
224  TUASSERTE(bool, true, uut2.transform(exp2, finalRF, out2));
225  TUASSERTFEPS(pos2[0], out2[0], 1e-4);
226  TUASSERTFEPS(pos2[1], out2[1], 1e-4);
227  TUASSERTFEPS(pos2[2], out2[2], 1e-4);
228 
229  TURETURN();
230 }
231 
232 
233 unsigned HelmertTransformer_T ::
234 transformXvtTest()
235 {
236  TUDEF("HelmertTransformer", "transform(Xvt)");
237 
238  gnsstk::Xvt pos1, exp1, out1;
239  pos1.x = gnsstk::Triple({p1[0], p1[1], p1[2]});
240  pos1.v = gnsstk::Triple({1, 2, 3});
241  pos1.clkbias = 4;
242  pos1.clkdrift = 5;
243  pos1.relcorr = 6;
244  pos1.frame = initialRF;
245  pos1.health = gnsstk::Xvt::Degraded;
246  out1.frame = finalRF;
247  exp1.x = gnsstk::Triple({x1[0], x1[1], x1[2]});
248  exp1.v = gnsstk::Triple({1, 2, 3});
249  exp1.clkbias = 4;
250  exp1.clkdrift = 5;
251  exp1.relcorr = 6;
252  exp1.frame = finalRF;
253  exp1.health = gnsstk::Xvt::Degraded;
254  TUASSERTE(bool, true, uut1.transform(pos1, out1));
255  TUASSERTFE(exp1.x[0], out1.x[0]);
256  TUASSERTFE(exp1.x[1], out1.x[1]);
257  TUASSERTFE(exp1.x[2], out1.x[2]);
258  TUASSERTFE(exp1.v[0], out1.v[0]);
259  TUASSERTFE(exp1.v[1], out1.v[1]);
260  TUASSERTFE(exp1.v[2], out1.v[2]);
261  TUASSERTFE(exp1.clkbias, out1.clkbias);
262  TUASSERTFE(exp1.clkdrift, out1.clkdrift);
263  TUASSERTFE(exp1.relcorr, out1.relcorr);
264  TUASSERTE(gnsstk::RefFrame, exp1.frame, out1.frame);
265  TUASSERTE(gnsstk::Xvt::HealthStatus, exp1.health, out1.health);
266 
267  gnsstk::Xvt pos2, exp2, out2;
268  pos2.x = gnsstk::Triple({p2[0], p2[1], p2[2]});
269  pos2.v = gnsstk::Triple({1, 2, 3});
270  pos2.clkbias = 4;
271  pos2.clkdrift = 5;
272  pos2.relcorr = 6;
273  pos2.frame = initialRF;
274  pos2.health = gnsstk::Xvt::Degraded;
275  out2.frame = finalRF;
276  exp2.x = gnsstk::Triple({x2[0], x2[1], x2[2]});
277  exp2.v = gnsstk::Triple({1, 2, 3});
278  exp2.clkbias = 4;
279  exp2.clkdrift = 5;
280  exp2.relcorr = 6;
281  exp2.frame = finalRF;
282  exp2.health = gnsstk::Xvt::Degraded;
283  // forward transform
284  TUASSERTE(bool, true, uut2.transform(pos2, out2));
285  TUASSERTFEPS(exp2.x[0], out2.x[0], 1e-4);
286  TUASSERTFEPS(exp2.x[1], out2.x[1], 1e-4);
287  TUASSERTFEPS(exp2.x[2], out2.x[2], 1e-4);
288  TUASSERTFEPS(exp2.v[0], out2.v[0], 1e-4);
289  TUASSERTFEPS(exp2.v[1], out2.v[1], 1e-4);
290  TUASSERTFEPS(exp2.v[2], out2.v[2], 1e-4);
291  TUASSERTFE(exp2.clkbias, out2.clkbias);
292  TUASSERTFE(exp2.clkdrift, out2.clkdrift);
293  TUASSERTFE(exp2.relcorr, out2.relcorr);
294  TUASSERTE(gnsstk::RefFrame, exp2.frame, out2.frame);
295  TUASSERTE(gnsstk::Xvt::HealthStatus, exp2.health, out2.health);
296  // reverse transform
297  out2.frame = initialRF;
298  TUASSERTE(bool, true, uut2.transform(exp2, out2));
299  TUASSERTFEPS(pos2.x[0], out2.x[0], 1e-4);
300  TUASSERTFEPS(pos2.x[1], out2.x[1], 1e-4);
301  TUASSERTFEPS(pos2.x[2], out2.x[2], 1e-4);
302  TUASSERTFEPS(pos2.v[0], out2.v[0], 1e-4);
303  TUASSERTFEPS(pos2.v[1], out2.v[1], 1e-4);
304  TUASSERTFEPS(pos2.v[2], out2.v[2], 1e-4);
305  TUASSERTFE(pos2.clkbias, out2.clkbias);
306  TUASSERTFE(pos2.clkdrift, out2.clkdrift);
307  TUASSERTFE(pos2.relcorr, out2.relcorr);
308  TUASSERTE(gnsstk::RefFrame, pos2.frame, out2.frame);
309  TUASSERTE(gnsstk::Xvt::HealthStatus, pos2.health, out2.health);
310 
311  TURETURN();
312 }
313 
314 
315 unsigned HelmertTransformer_T ::
316 transformdoubleTest()
317 {
318  TUDEF("HelmertTransformer", "transform(double)");
319 
320  double out1x, out1y, out1z;
321  TUASSERTE(bool, true, uut1.transform(p1[0], p1[1], p1[2], initialRF, out1x, out1y, out1z));
322  TUASSERTFE(x1[0], out1x);
323  TUASSERTFE(x1[1], out1y);
324  TUASSERTFE(x1[2], out1z);
325 
326  double out2x, out2y, out2z;
327  // forward transform
328  TUASSERTE(bool, true, uut2.transform(p2[0], p2[1], p2[2], initialRF, out2x, out2y, out2z));
329  TUASSERTFEPS(x2[0], out2x, 1e-4);
330  TUASSERTFEPS(x2[1], out2y, 1e-4);
331  TUASSERTFEPS(x2[2], out2z, 1e-4);
332  // reverse transform
333  TUASSERTE(bool, true, uut2.transform(x2[0], x2[1], x2[2], finalRF, out2x, out2y, out2z));
334  TUASSERTFEPS(p2[0], out2x, 1e-4);
335  TUASSERTFEPS(p2[1], out2y, 1e-4);
336  TUASSERTFEPS(p2[2], out2z, 1e-4);
337 
338  TURETURN();
339 }
340 
341 
342 int main()
343 {
344  HelmertTransformer_T testClass;
345  unsigned errorTotal = 0;
346 
347  errorTotal += testClass.constructorTest();
348  errorTotal += testClass.transformPositionTest();
349  errorTotal += testClass.transformVectorTest();
350  errorTotal += testClass.transformTripleTest();
351  errorTotal += testClass.transformXvtTest();
352  errorTotal += testClass.transformdoubleTest();
353 
354  std::cout << "Total Failures for " << __FILE__ << ": " << errorTotal
355  << std::endl;
356 
357  return errorTotal;
358 }
TestClass::getty
double getty() const
Definition: HelmertTransformer_T.cpp:52
YDSTime.hpp
HelmertTransformer_T::finalRF
gnsstk::RefFrame finalRF
Definition: HelmertTransformer_T.cpp:71
gnsstk::Position::Cartesian
@ Cartesian
cartesian (Earth-centered, Earth-fixed)
Definition: Position.hpp:147
gnsstk::Transformer::getFromFrame
const RefFrame & getFromFrame() const noexcept
Return the RefFrame this Transformer will convert from.
Definition: Transformer.hpp:143
gnsstk::HelmertTransformer::transform
bool transform(const Position &fromPos, Position &toPos) const noexcept override
Definition: HelmertTransformer.cpp:111
TestClass::gettz
double gettz() const
Definition: HelmertTransformer_T.cpp:53
gnsstk::Position::setReferenceFrame
void setReferenceFrame(const RefFrame &frame) noexcept
Definition: Position.cpp:467
gnsstk::YDSTime
Definition: YDSTime.hpp:58
main
int main()
Definition: HelmertTransformer_T.cpp:342
TestClass::getdescription
std::string getdescription() const
Definition: HelmertTransformer_T.cpp:55
HelmertTransformer_T::x1
std::vector< double > x1
Definition: HelmertTransformer_T.cpp:74
TUASSERTE
#define TUASSERTE(TYPE, EXP, GOT)
Definition: TestUtil.hpp:81
gnsstk::HelmertTransformer
Definition: HelmertTransformer.hpp:52
gnsstk::rotation
Matrix< T > rotation(T angle, int axis)
Definition: MatrixOperators.hpp:495
HelmertTransformer_T::p1
std::vector< double > p1
initial positions and transformed positions
Definition: HelmertTransformer_T.cpp:74
gnsstk::Position::getZ
double getZ() const noexcept
return ECEF Z coordinate (meters)
Definition: Position.hpp:489
gnsstk::Xvt::frame
RefFrame frame
reference frame of this data
Definition: Xvt.hpp:156
gnsstk::PPB
static const double PPB
parts per billion
Definition: GNSSconstants.hpp:84
gnsstk::Xvt::v
Triple v
satellite velocity in ECEF Cartesian, meters/second
Definition: Xvt.hpp:152
gnsstk::RefFrame
Definition: RefFrame.hpp:53
gnsstk::Triple
Definition: Triple.hpp:68
gnsstk
For Sinex::InputHistory.
Definition: BasicFramework.cpp:50
gnsstk::Xvt::relcorr
double relcorr
relativity correction (standard 2R.V/c^2 term), seconds
Definition: Xvt.hpp:155
TestClass::getscale
double getscale() const
Definition: HelmertTransformer_T.cpp:54
gnsstk::HelmertTransformer::HelmertTransformer
HelmertTransformer()
Initialize everything to invalid values.
Definition: HelmertTransformer.cpp:44
gnsstk::Xvt::x
Triple x
Sat position ECEF Cartesian (X,Y,Z) meters.
Definition: Xvt.hpp:151
TestUtil.hpp
HelmertTransformer_T::x2
std::vector< double > x2
Definition: HelmertTransformer_T.cpp:74
TestClass::getrz
double getrz() const
Definition: HelmertTransformer_T.cpp:50
HelmertTransformer_T::transformVectorTest
unsigned transformVectorTest()
Definition: HelmertTransformer_T.cpp:172
TURETURN
#define TURETURN()
Definition: TestUtil.hpp:232
gnsstk::Position::getX
double getX() const noexcept
return ECEF X coordinate (meters)
Definition: Position.hpp:479
HelmertTransformer_T::constructorTest
unsigned constructorTest()
Definition: HelmertTransformer_T.cpp:100
HelmertTransformer_T::transformdoubleTest
unsigned transformdoubleTest()
Definition: HelmertTransformer_T.cpp:316
TestClass::getrx
double getrx() const
Definition: HelmertTransformer_T.cpp:48
gnsstk::CommonTime
Definition: CommonTime.hpp:84
gnsstk::Xvt::clkdrift
double clkdrift
satellite clock drift in seconds/second
Definition: Xvt.hpp:154
gnsstk::TimeSystem
TimeSystem
Definition of various time systems.
Definition: TimeSystem.hpp:51
HelmertTransformer_T::p2
std::vector< double > p2
Definition: HelmertTransformer_T.cpp:74
TUASSERTFEPS
#define TUASSERTFEPS(EXP, GOT, EPS)
Definition: TestUtil.hpp:126
gnsstk::Xvt
Definition: Xvt.hpp:60
TestClass::gettx
double gettx() const
Definition: HelmertTransformer_T.cpp:51
gnsstk::RefFrameSys
RefFrameSys
Reference frame systems. For specific realizations, see RefFrameRlz.
Definition: RefFrameSys.hpp:51
TUDEF
#define TUDEF(CLASS, METHOD)
Definition: TestUtil.hpp:56
gnsstk::Vector< double >
HelmertTransformer_T::transformPositionTest
unsigned transformPositionTest()
Definition: HelmertTransformer_T.cpp:135
gnsstk::TimeSystem::UTC
@ UTC
Coordinated Universal Time (e.g., from NTP)
HelmertTransformer_T::transformXvtTest
unsigned transformXvtTest()
Definition: HelmertTransformer_T.cpp:234
gnsstk::Transformer::getToFrame
const RefFrame & getToFrame() const noexcept
Return the RefFrame this Transformer will convert to.
Definition: Transformer.hpp:146
gnsstk::Xvt::HealthStatus
HealthStatus
Definition: Xvt.hpp:87
gnsstk::Xvt::health
HealthStatus health
Health status of satellite at ref time.
Definition: Xvt.hpp:157
gnsstk::RefFrameRlz::PZ90Y2007
@ PZ90Y2007
PZ90 (GLONASS), 2007 version.
gnsstk::Position::getY
double getY() const noexcept
return ECEF Y coordinate (meters)
Definition: Position.hpp:484
gnsstk::RefFrameRlz::WGS84G1150
@ WGS84G1150
WGS84, GPS week 1150 version.
gnsstk::DEG_PER_MAS
static const double DEG_PER_MAS
degrees per milliarcsecond (1e-3/3600.)
Definition: GNSSconstants.hpp:80
TestClass
Make GroupPathCorrector instantiatable for testing.
Definition: GroupPathCorrector_T.cpp:56
TUASSERTFE
#define TUASSERTFE(EXP, GOT)
Definition: TestUtil.hpp:103
gnsstk::Position
Definition: Position.hpp:136
gnsstk::Xvt::Degraded
@ Degraded
Sat is in a degraded state, recommend do not use.
Definition: Xvt.hpp:95
TestClass::getry
double getry() const
Definition: HelmertTransformer_T.cpp:49
gnsstk::Xvt::clkbias
double clkbias
Sat clock correction in seconds.
Definition: Xvt.hpp:153
HelmertTransformer_T::HelmertTransformer_T
HelmertTransformer_T()
Definition: HelmertTransformer_T.cpp:79
HelmertTransformer_T
Definition: HelmertTransformer_T.cpp:59
HelmertTransformer_T::initialRF
gnsstk::RefFrame initialRF
Definition: HelmertTransformer_T.cpp:70
HelmertTransformer_T::transformTripleTest
unsigned transformTripleTest()
Definition: HelmertTransformer_T.cpp:203
HelmertTransformer.hpp
HelmertTransformer_T::uut2
gnsstk::HelmertTransformer uut2
Definition: HelmertTransformer_T.cpp:72
HelmertTransformer_T::uut1
gnsstk::HelmertTransformer uut1
Definition: HelmertTransformer_T.cpp:72
gnsstk::Transformer::getEpoch
const CommonTime & getEpoch() const noexcept
Definition: Transformer.hpp:153
gnsstk::DEG_TO_RAD
static const double DEG_TO_RAD
Conversion Factor from degrees to radians (units: degrees^-1)
Definition: GNSSconstants.hpp:76

gnsstk
Author(s):
autogenerated on Wed Oct 25 2023 02:40:39