HelmertTransform_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 "HelmertTransform.hpp"
41 #include "YDSTime.hpp"
42 
44 class TestClass : public gnsstk::HelmertTransform
45 {
46 public:
47  using gnsstk::HelmertTransform::HelmertTransform;
48  double getrx() const { return rx; }
49  double getry() const { return ry; }
50  double getrz() const { return rz; }
51  double gettx() const { return tx; }
52  double getty() const { return ty; }
53  double gettz() const { return tz; }
54  double getscale() const { return scale; }
55  std::string getdescription() const { return description; }
56 };
57 
58 class HelmertTransform_T
59 {
60 public:
61  HelmertTransform_T();
62  unsigned constructorTest();
63  unsigned transformPositionTest();
64  unsigned transformVectorTest();
65  unsigned transformTripleTest();
66  unsigned transformXvtTest();
67  unsigned transformdoubleTest();
68 
69  gnsstk::ReferenceFrame initialRF;
70  gnsstk::ReferenceFrame finalRF;
71  gnsstk::RefFrame initRF;
72  gnsstk::RefFrame finRF;
73  gnsstk::HelmertTransform uut1, uut2;
75  std::vector<double> p1, x1, p2, x2;
76 };
77 
78 
79 HelmertTransform_T ::
80 HelmertTransform_T()
81  : initialRF(gnsstk::ReferenceFrame::WGS84),
82  initRF(initialRF,gnsstk::YDSTime(2020,123,456,gnsstk::TimeSystem::UTC)),
83  finalRF(gnsstk::ReferenceFrame::CGCS2000),
84  finRF(finalRF, gnsstk::YDSTime(1994,1,0,gnsstk::TimeSystem::UTC)),
85  uut1(initialRF, finalRF, 0, 0, 0, 10, 10, 10, 1, "hi there",
86  gnsstk::YDSTime(2020,123,456,gnsstk::TimeSystem::UTC)),
87  // https://d28rz98at9flks.cloudfront.net/71433/71433.pdf
88  uut2(initialRF, finalRF, -24.1665*gnsstk::DEG_PER_MAS,
89  -20.9515*gnsstk::DEG_PER_MAS, -21.3961*gnsstk::DEG_PER_MAS,
90  -42.7e-3, -17.06e-3, 28.81e-3, 11.474*gnsstk::PPB, "step 2",
91  gnsstk::YDSTime(1994, 1, 0,gnsstk::TimeSystem::UTC)),
92  p1({150, 150, 150}),
93  x1({310, 310, 310}), // 100% scale, 10m translation
94  p2({-4052052.3678, 4212836.0411, -2545105.1089}),
95  x2({-4052051.7615, 4212836.1945, -2545106.0145})
96 {
97 }
98 
99 
100 unsigned HelmertTransform_T ::
101 constructorTest()
102 {
103  TUDEF("HelmertTransform", "HelmertTransform");
104  TestClass uut1;
105  TUASSERTE(gnsstk::ReferenceFrame, gnsstk::ReferenceFrame::Unknown,
106  uut1.getFromFrame());
107  TUASSERTE(gnsstk::ReferenceFrame, gnsstk::ReferenceFrame::Unknown,
108  uut1.getToFrame());
109  TUASSERTE(int, 1, std::isnan(uut1.getrx()));
110  TUASSERTE(int, 1, std::isnan(uut1.getry()));
111  TUASSERTE(int, 1, std::isnan(uut1.getrz()));
112  TUASSERTE(int, 1, std::isnan(uut1.gettx()));
113  TUASSERTE(int, 1, std::isnan(uut1.getty()));
114  TUASSERTE(int, 1, std::isnan(uut1.gettz()));
115  TUASSERTE(int, 1, std::isnan(uut1.getscale()));
116 
117  TestClass uut2(gnsstk::ReferenceFrame::PZ90, gnsstk::ReferenceFrame::WGS84,
118  1e-4, 2e-4, 3e-4, 4, 5, 6, 7, "hi there",
119  gnsstk::YDSTime(2020,123,456,gnsstk::TimeSystem::UTC));
120  TUASSERTE(gnsstk::ReferenceFrame, gnsstk::ReferenceFrame::PZ90,
121  uut2.getFromFrame());
122  TUASSERTE(gnsstk::ReferenceFrame, gnsstk::ReferenceFrame::WGS84,
123  uut2.getToFrame());
124  TUASSERTFE(1e-4*gnsstk::DEG_TO_RAD, uut2.getrx());
125  TUASSERTFE(2e-4*gnsstk::DEG_TO_RAD, uut2.getry());
126  TUASSERTFE(3e-4*gnsstk::DEG_TO_RAD, uut2.getrz());
127  TUASSERTFE(4, uut2.gettx());
128  TUASSERTFE(5, uut2.getty());
129  TUASSERTFE(6, uut2.gettz());
130  TUASSERTFE(7, uut2.getscale());
131  TUASSERTE(std::string, "hi there", uut2.getdescription());
132  TUASSERTE(gnsstk::CommonTime,
133  gnsstk::YDSTime(2020,123,456,gnsstk::TimeSystem::UTC),
134  uut2.getEpoch());
135  TURETURN();
136 }
137 
138 
139 unsigned HelmertTransform_T ::
140 transformPositionTest()
141 {
142  TUDEF("HelmertTransform", "transform(Position)");
143 
144  gnsstk::Position pos1(&p1[0], gnsstk::Position::Cartesian, nullptr,
145  initRF);
146  gnsstk::Position exp1(&x1[0], gnsstk::Position::Cartesian, nullptr,
147  finRF);
148  gnsstk::Position out1;
149  TUCATCH(uut1.transform(pos1, out1));
150  TUASSERTFE(exp1.getX(), out1.getX());
151  TUASSERTFE(exp1.getY(), out1.getY());
152  TUASSERTFE(exp1.getZ(), out1.getZ());
153 
154  gnsstk::Position pos2(&p2[0], gnsstk::Position::Cartesian, nullptr,
155  initRF);
156  gnsstk::Position exp2(&x2[0], gnsstk::Position::Cartesian, nullptr, finRF);
157  gnsstk::Position out2;
158  // forward transform
159  TUCATCH(uut2.transform(pos2, out2));
160  TUASSERTFEPS(exp2.getX(), out2.getX(), 1e-4);
161  TUASSERTFEPS(exp2.getY(), out2.getY(), 1e-4);
162  TUASSERTFEPS(exp2.getZ(), out2.getZ(), 1e-4);
163  // reverse transform
164  TUCATCH(uut2.transform(exp2, out2));
165  TUASSERTFEPS(pos2.getX(), out2.getX(), 1e-4);
166  TUASSERTFEPS(pos2.getY(), out2.getY(), 1e-4);
167  TUASSERTFEPS(pos2.getZ(), out2.getZ(), 1e-4);
168 
169  TURETURN();
170 }
171 
172 
173 unsigned HelmertTransform_T ::
174 transformVectorTest()
175 {
176  TUDEF("HelmertTransform", "transform(Vector)");
177 
178  gnsstk::Vector<double> pos1({p1[0], p1[1], p1[2]});
179  gnsstk::Vector<double> exp1({x1[0], x1[1], x1[2]});
180  gnsstk::Vector<double> out1;
181  TUCATCH(uut1.transform(pos1, initialRF, out1));
182  TUASSERTFE(exp1[0], out1[0]);
183  TUASSERTFE(exp1[1], out1[1]);
184  TUASSERTFE(exp1[2], out1[2]);
185 
186  gnsstk::Vector<double> pos2({p2[0], p2[1], p2[2]});
187  gnsstk::Vector<double> exp2({x2[0], x2[1], x2[2]});
188  gnsstk::Vector<double> out2;
189  // forward transform
190  TUCATCH(uut2.transform(pos2, initialRF, out2));
191  TUASSERTFEPS(exp2[0], out2[0], 1e-4);
192  TUASSERTFEPS(exp2[1], out2[1], 1e-4);
193  TUASSERTFEPS(exp2[2], out2[2], 1e-4);
194  // reverse transform
195  TUCATCH(uut2.transform(exp2, finalRF, out2));
196  TUASSERTFEPS(pos2[0], out2[0], 1e-4);
197  TUASSERTFEPS(pos2[1], out2[1], 1e-4);
198  TUASSERTFEPS(pos2[2], out2[2], 1e-4);
199 
200  TURETURN();
201 }
202 
203 
204 unsigned HelmertTransform_T ::
205 transformTripleTest()
206 {
207  TUDEF("HelmertTransform", "transform(Triple)");
208 
209  gnsstk::Triple pos1({p1[0], p1[1], p1[2]});
210  gnsstk::Triple exp1({x1[0], x1[1], x1[2]});
211  gnsstk::Triple out1;
212  TUCATCH(uut1.transform(pos1, initialRF, out1));
213  TUASSERTFE(exp1[0], out1[0]);
214  TUASSERTFE(exp1[1], out1[1]);
215  TUASSERTFE(exp1[2], out1[2]);
216 
217  gnsstk::Triple pos2({p2[0], p2[1], p2[2]});
218  gnsstk::Triple exp2({x2[0], x2[1], x2[2]});
219  gnsstk::Triple out2;
220  // forward transform
221  TUCATCH(uut2.transform(pos2, initialRF, out2));
222  TUASSERTFEPS(exp2[0], out2[0], 1e-4);
223  TUASSERTFEPS(exp2[1], out2[1], 1e-4);
224  TUASSERTFEPS(exp2[2], out2[2], 1e-4);
225  // reverse transform
226  TUCATCH(uut2.transform(exp2, finalRF, out2));
227  TUASSERTFEPS(pos2[0], out2[0], 1e-4);
228  TUASSERTFEPS(pos2[1], out2[1], 1e-4);
229  TUASSERTFEPS(pos2[2], out2[2], 1e-4);
230 
231  TURETURN();
232 }
233 
234 
235 unsigned HelmertTransform_T ::
236 transformXvtTest()
237 {
238  TUDEF("HelmertTransform", "transform(Xvt)");
239 
240  gnsstk::Xvt pos1, exp1, out1;
241  pos1.x = gnsstk::Triple({p1[0], p1[1], p1[2]});
242  pos1.v = gnsstk::Triple({1, 2, 3});
243  pos1.clkbias = 4;
244  pos1.clkdrift = 5;
245  pos1.relcorr = 6;
246  pos1.frame = initRF;
247  pos1.health = gnsstk::Xvt::Degraded;
248  exp1.x = gnsstk::Triple({x1[0], x1[1], x1[2]});
249  exp1.v = gnsstk::Triple({1, 2, 3});
250  exp1.clkbias = 4;
251  exp1.clkdrift = 5;
252  exp1.relcorr = 6;
253  exp1.frame = finRF;
254  exp1.health = gnsstk::Xvt::Degraded;
255  TUCATCH(uut1.transform(pos1, out1));
256  TUASSERTFE(exp1.x[0], out1.x[0]);
257  TUASSERTFE(exp1.x[1], out1.x[1]);
258  TUASSERTFE(exp1.x[2], out1.x[2]);
259  TUASSERTFE(exp1.v[0], out1.v[0]);
260  TUASSERTFE(exp1.v[1], out1.v[1]);
261  TUASSERTFE(exp1.v[2], out1.v[2]);
262  TUASSERTFE(exp1.clkbias, out1.clkbias);
263  TUASSERTFE(exp1.clkdrift, out1.clkdrift);
264  TUASSERTFE(exp1.relcorr, out1.relcorr);
265  TUASSERTE(gnsstk::RefFrame, exp1.frame, out1.frame);
266  TUASSERTE(gnsstk::Xvt::HealthStatus, exp1.health, out1.health);
267 
268  gnsstk::Xvt pos2, exp2, out2;
269  pos2.x = gnsstk::Triple({p2[0], p2[1], p2[2]});
270  pos2.v = gnsstk::Triple({1, 2, 3});
271  pos2.clkbias = 4;
272  pos2.clkdrift = 5;
273  pos2.relcorr = 6;
274  pos2.frame = gnsstk::RefFrame(gnsstk::RefFrameSys::WGS84, uut2.getEpoch());
275  pos2.health = gnsstk::Xvt::Degraded;
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 = finRF;
282  exp2.health = gnsstk::Xvt::Degraded;
283  // forward transform
284  TUCATCH(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  TUCATCH(uut2.transform(exp2, out2));
298  TUASSERTFEPS(pos2.x[0], out2.x[0], 1e-4);
299  TUASSERTFEPS(pos2.x[1], out2.x[1], 1e-4);
300  TUASSERTFEPS(pos2.x[2], out2.x[2], 1e-4);
301  TUASSERTFEPS(pos2.v[0], out2.v[0], 1e-4);
302  TUASSERTFEPS(pos2.v[1], out2.v[1], 1e-4);
303  TUASSERTFEPS(pos2.v[2], out2.v[2], 1e-4);
304  TUASSERTFE(pos2.clkbias, out2.clkbias);
305  TUASSERTFE(pos2.clkdrift, out2.clkdrift);
306  TUASSERTFE(pos2.relcorr, out2.relcorr);
307  TUASSERTE(gnsstk::RefFrame, pos2.frame, out2.frame);
308  TUASSERTE(gnsstk::Xvt::HealthStatus, pos2.health, out2.health);
309 
310  TURETURN();
311 }
312 
313 
314 unsigned HelmertTransform_T ::
315 transformdoubleTest()
316 {
317  TUDEF("HelmertTransform", "transform(double)");
318 
319  double out1x, out1y, out1z;
320  TUCATCH(uut1.transform(p1[0], p1[1], p1[2], initialRF, out1x, out1y, out1z));
321  TUASSERTFE(x1[0], out1x);
322  TUASSERTFE(x1[1], out1y);
323  TUASSERTFE(x1[2], out1z);
324 
325  double out2x, out2y, out2z;
326  // forward transform
327  TUCATCH(uut2.transform(p2[0], p2[1], p2[2], initialRF, out2x, out2y, out2z));
328  TUASSERTFEPS(x2[0], out2x, 1e-4);
329  TUASSERTFEPS(x2[1], out2y, 1e-4);
330  TUASSERTFEPS(x2[2], out2z, 1e-4);
331  // reverse transform
332  TUCATCH(uut2.transform(x2[0], x2[1], x2[2], finalRF, out2x, out2y, out2z));
333  TUASSERTFEPS(p2[0], out2x, 1e-4);
334  TUASSERTFEPS(p2[1], out2y, 1e-4);
335  TUASSERTFEPS(p2[2], out2z, 1e-4);
336 
337  TURETURN();
338 }
339 
340 
341 int main()
342 {
343  HelmertTransform_T testClass;
344  unsigned errorTotal = 0;
345 
346  errorTotal += testClass.constructorTest();
347  errorTotal += testClass.transformPositionTest();
348  errorTotal += testClass.transformVectorTest();
349  errorTotal += testClass.transformTripleTest();
350  errorTotal += testClass.transformXvtTest();
351  errorTotal += testClass.transformdoubleTest();
352 
353  std::cout << "Total Failures for " << __FILE__ << ": " << errorTotal
354  << std::endl;
355 
356  return errorTotal;
357 }
gnsstk::HelmertTransform::transform
void transform(const Position &pos, Position &result)
Definition: HelmertTransform.cpp:151
TestClass::getty
double getty() const
Definition: HelmertTransform_T.cpp:52
YDSTime.hpp
gnsstk::ReferenceFrame
ReferenceFrame
Definition: ReferenceFrame.hpp:52
gnsstk::Position::Cartesian
@ Cartesian
cartesian (Earth-centered, Earth-fixed)
Definition: Position.hpp:147
TUCATCH
#define TUCATCH(STATEMENT)
Definition: TestUtil.hpp:193
TestClass::gettz
double gettz() const
Definition: HelmertTransform_T.cpp:53
HelmertTransform_T::constructorTest
unsigned constructorTest()
Definition: HelmertTransform_T.cpp:101
HelmertTransform_T::transformdoubleTest
unsigned transformdoubleTest()
Definition: HelmertTransform_T.cpp:315
HelmertTransform_T::finRF
gnsstk::RefFrame finRF
Definition: HelmertTransform_T.cpp:72
HelmertTransform_T::HelmertTransform_T
HelmertTransform_T()
Definition: HelmertTransform_T.cpp:80
gnsstk::YDSTime
Definition: YDSTime.hpp:58
gnsstk::ReferenceFrame::Unknown
@ Unknown
unknown frame
TestClass::getdescription
std::string getdescription() const
Definition: HelmertTransform_T.cpp:55
TUASSERTE
#define TUASSERTE(TYPE, EXP, GOT)
Definition: TestUtil.hpp:81
gnsstk::Position::getZ
double getZ() const noexcept
return ECEF Z coordinate (meters)
Definition: Position.hpp:489
HelmertTransform_T::x1
std::vector< double > x1
Definition: HelmertTransform_T.cpp:75
HelmertTransform_T::finalRF
gnsstk::ReferenceFrame finalRF
Definition: HelmertTransform_T.cpp:70
gnsstk::Xvt::frame
RefFrame frame
reference frame of this data
Definition: Xvt.hpp:156
HelmertTransform_T::uut1
gnsstk::HelmertTransform uut1
Definition: HelmertTransform_T.cpp:73
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
HelmertTransform_T::p2
std::vector< double > p2
Definition: HelmertTransform_T.cpp:75
gnsstk::Xvt::relcorr
double relcorr
relativity correction (standard 2R.V/c^2 term), seconds
Definition: Xvt.hpp:155
HelmertTransform_T
Definition: HelmertTransform_T.cpp:58
TestClass::getscale
double getscale() const
Definition: HelmertTransform_T.cpp:54
HelmertTransform_T::x2
std::vector< double > x2
Definition: HelmertTransform_T.cpp:75
gnsstk::Xvt::x
Triple x
Sat position ECEF Cartesian (X,Y,Z) meters.
Definition: Xvt.hpp:151
HelmertTransform_T::p1
std::vector< double > p1
initial positions and transformed positions
Definition: HelmertTransform_T.cpp:75
TestUtil.hpp
TestClass::getrz
double getrz() const
Definition: HelmertTransform_T.cpp:50
TURETURN
#define TURETURN()
Definition: TestUtil.hpp:232
gnsstk::Position::getX
double getX() const noexcept
return ECEF X coordinate (meters)
Definition: Position.hpp:479
HelmertTransform_T::initRF
gnsstk::RefFrame initRF
Definition: HelmertTransform_T.cpp:71
TestClass::getrx
double getrx() const
Definition: HelmertTransform_T.cpp:48
gnsstk::CommonTime
Definition: CommonTime.hpp:84
gnsstk::ReferenceFrame::WGS84
@ WGS84
WGS84, assumed to be the latest version.
gnsstk::Xvt::clkdrift
double clkdrift
satellite clock drift in seconds/second
Definition: Xvt.hpp:154
gnsstk::RefFrameSys::WGS84
@ WGS84
The reference frame used by GPS.
gnsstk::TimeSystem
TimeSystem
Definition of various time systems.
Definition: TimeSystem.hpp:51
gnsstk::HelmertTransform::getEpoch
CommonTime getEpoch() const noexcept
Get the time at which this transform becomes valid.
Definition: HelmertTransform.hpp:205
TUASSERTFEPS
#define TUASSERTFEPS(EXP, GOT, EPS)
Definition: TestUtil.hpp:126
gnsstk::Xvt
Definition: Xvt.hpp:60
gnsstk::HelmertTransform::getFromFrame
ReferenceFrame getFromFrame() const noexcept
Get the reference frame this transform can convert from (or to).
Definition: HelmertTransform.hpp:197
TestClass::gettx
double gettx() const
Definition: HelmertTransform_T.cpp:51
TUDEF
#define TUDEF(CLASS, METHOD)
Definition: TestUtil.hpp:56
gnsstk::HelmertTransform::getToFrame
ReferenceFrame getToFrame() const noexcept
Get the reference frame this transform can convert to (or from).
Definition: HelmertTransform.hpp:201
gnsstk::Vector< double >
gnsstk::TimeSystem::UTC
@ UTC
Coordinated Universal Time (e.g., from NTP)
gnsstk::Xvt::HealthStatus
HealthStatus
Definition: Xvt.hpp:87
gnsstk::Xvt::health
HealthStatus health
Health status of satellite at ref time.
Definition: Xvt.hpp:157
main
int main()
Definition: HelmertTransform_T.cpp:341
gnsstk::HelmertTransform
Definition: HelmertTransform.hpp:63
gnsstk::HelmertTransform::HelmertTransform
HelmertTransform() noexcept
Default constructor.
Definition: HelmertTransform.cpp:53
gnsstk::Position::getY
double getY() const noexcept
return ECEF Y coordinate (meters)
Definition: Position.hpp:484
HelmertTransform_T::transformXvtTest
unsigned transformXvtTest()
Definition: HelmertTransform_T.cpp:236
gnsstk::DEG_PER_MAS
static const double DEG_PER_MAS
degrees per milliarcsecond (1e-3/3600.)
Definition: GNSSconstants.hpp:80
gnsstk::ReferenceFrame::PZ90
@ PZ90
PZ90 (GLONASS)
HelmertTransform_T::transformPositionTest
unsigned transformPositionTest()
Definition: HelmertTransform_T.cpp:140
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: HelmertTransform_T.cpp:49
gnsstk::Xvt::clkbias
double clkbias
Sat clock correction in seconds.
Definition: Xvt.hpp:153
HelmertTransform_T::uut2
gnsstk::HelmertTransform uut2
Definition: HelmertTransform_T.cpp:73
HelmertTransform.hpp
HelmertTransform_T::transformTripleTest
unsigned transformTripleTest()
Definition: HelmertTransform_T.cpp:205
HelmertTransform_T::transformVectorTest
unsigned transformVectorTest()
Definition: HelmertTransform_T.cpp:174
gnsstk::DEG_TO_RAD
static const double DEG_TO_RAD
Conversion Factor from degrees to radians (units: degrees^-1)
Definition: GNSSconstants.hpp:76
HelmertTransform_T::initialRF
gnsstk::ReferenceFrame initialRF
Definition: HelmertTransform_T.cpp:69

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