0.5.1
Loading...
Searching...
No Matches
RtklibPosFile.cpp
Go to the documentation of this file.
1// This file is part of INSTINCT, the INS Toolkit for Integrated
2// Navigation Concepts and Training by the Institute of Navigation of
3// the University of Stuttgart, Germany.
4//
5// This Source Code Form is subject to the terms of the Mozilla Public
6// License, v. 2.0. If a copy of the MPL was not distributed with this
7// file, You can obtain one at https://mozilla.org/MPL/2.0/.
8
9#include "RtklibPosFile.hpp"
10
11#include "util/Logger.hpp"
12#include "Navigation/Transformations/CoordinateFrames.hpp"
13#include "Navigation/Transformations/Units.hpp"
14#include "util/Time/TimeBase.hpp"
15#include "util/StringUtil.hpp"
16
17#include "internal/FlowManager.hpp"
18
19#include "NodeData/GNSS/RtklibPosObs.hpp"
20
31
36
37std::string NAV::RtklibPosFile::typeStatic()
38{
39 return "RtklibPosFile";
40}
41
42std::string NAV::RtklibPosFile::type() const
43{
44 return typeStatic();
45}
46
47std::string NAV::RtklibPosFile::category()
48{
49 return "Data Provider";
50}
51
52void NAV::RtklibPosFile::guiConfig()
53{
54 if (auto res = FileReader::guiConfig(".pos,.*", { ".pos" }, size_t(id), nameId()))
55 {
56 LOG_DEBUG("{}: Path changed to {}", nameId(), _path);
57 flow::ApplyChanges();
58 if (res == FileReader::PATH_CHANGED)
59 {
60 doReinitialize();
61 }
62 else
63 {
64 doDeinitialize();
65 }
66 }
67
68 /// Header info
69 if (ImGui::BeginTable(fmt::format("##RtklibPos ({})", id.AsPointer()).c_str(), 4,
70 ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_NoHostExtendX))
71 {
72 ImGui::TableSetupColumn("Basic", ImGuiTableColumnFlags_WidthFixed);
73 ImGui::TableSetupColumn("LLA", ImGuiTableColumnFlags_WidthFixed);
74 ImGui::TableSetupColumn("XYZ", ImGuiTableColumnFlags_WidthFixed);
75 ImGui::TableSetupColumn("Velocity", ImGuiTableColumnFlags_WidthFixed);
76 ImGui::TableHeadersRow();
77
78 auto TextColoredIfExists = [this](int index, const char* displayText, const char* searchText, bool alwaysNormal = false) {
79 ImGui::TableSetColumnIndex(index);
80 if (alwaysNormal || std::ranges::find_if(_headerColumns, [&searchText](const std::string& header) { return header.starts_with(searchText); }) != _headerColumns.end())
81 {
82 ImGui::TextUnformatted(displayText);
83 }
84 else
85 {
86 ImGui::TextDisabled("%s", displayText);
87 }
88 };
89
90 ImGui::TableNextRow();
91 TextColoredIfExists(0, "Date", "Date");
92 TextColoredIfExists(1, "latitude(deg)", "latitude(deg)");
93 TextColoredIfExists(2, "x-ecef(m)", "x-ecef(m)");
94 TextColoredIfExists(3, "vn(m/s)", "vn(m/s)");
95 ImGui::TableNextRow();
96 TextColoredIfExists(0, "Time", "Time");
97 TextColoredIfExists(1, "longitude(deg)", "longitude(deg)");
98 TextColoredIfExists(2, "y-ecef(m)", "y-ecef(m)");
99 TextColoredIfExists(3, "ve(m/s)", "ve(m/s)");
100 ImGui::TableNextRow();
101 TextColoredIfExists(0, "age(s)", "age(s)");
102 TextColoredIfExists(1, "height(m)", "height(m)");
103 TextColoredIfExists(2, "z-ecef(m)", "z-ecef(m)");
104 TextColoredIfExists(3, "vu(m/s)", "vu(m/s)");
105 ImGui::TableNextRow();
106 TextColoredIfExists(0, "ratio", "ratio");
107 TextColoredIfExists(1, "sdn(m)", "sdn(m)");
108 TextColoredIfExists(2, "sdx(m)", "sdx(m)");
109 TextColoredIfExists(3, "sdvn", "sdvn");
110 ImGui::TableNextRow();
111 TextColoredIfExists(0, "Q", "Q");
112 TextColoredIfExists(1, "sde(m)", "sde(m)");
113 TextColoredIfExists(2, "sdy(m)", "sdy(m)");
114 TextColoredIfExists(3, "sdve", "sdve");
115 ImGui::TableNextRow();
116 TextColoredIfExists(0, "ns", "ns");
117 TextColoredIfExists(1, "sdu(m)", "sdu(m)");
118 TextColoredIfExists(2, "sdz(m)", "sdz(m)");
119 TextColoredIfExists(3, "sdvu", "sdvu");
120 ImGui::TableNextRow();
121 TextColoredIfExists(1, "sdne(m)", "sdne(m)");
122 TextColoredIfExists(2, "sdxy(m)", "sdxy(m)");
123 TextColoredIfExists(3, "sdvne", "sdvne");
124 ImGui::TableNextRow();
125 TextColoredIfExists(1, "sdeu(m)", "sdeu(m)");
126 TextColoredIfExists(2, "sdyz(m)", "sdyz(m)");
127 TextColoredIfExists(3, "sdveu", "sdveu");
128 ImGui::TableNextRow();
129 TextColoredIfExists(1, "sdun(m)", "sdun(m)");
130 TextColoredIfExists(2, "sdzx(m)", "sdzx(m)");
131 TextColoredIfExists(3, "sdvun", "sdvun");
132
133 ImGui::EndTable();
134 }
135}
136
137[[nodiscard]] json NAV::RtklibPosFile::save() const
138{
139 LOG_TRACE("{}: called", nameId());
140
141 json j;
142
143 j["FileReader"] = FileReader::save();
144
145 return j;
146}
147
148void NAV::RtklibPosFile::restore(json const& j)
149{
150 LOG_TRACE("{}: called", nameId());
151
152 if (j.contains("FileReader"))
153 {
154 FileReader::restore(j.at("FileReader"));
155 }
156}
157
158bool NAV::RtklibPosFile::initialize()
159{
160 LOG_TRACE("{}: called", nameId());
161
162 return FileReader::initialize();
163}
164
165void NAV::RtklibPosFile::deinitialize()
166{
167 LOG_TRACE("{}: called", nameId());
168
169 FileReader::deinitialize();
170}
171
172bool NAV::RtklibPosFile::resetNode()
173{
174 FileReader::resetReader();
175
176 return true;
177}
178
179std::shared_ptr<const NAV::NodeData> NAV::RtklibPosFile::pollData()
180{
181 auto obs = std::make_shared<RtklibPosObs>();
182
183 // Read line
184 std::string line;
185 getline(line);
186 // Remove any starting non text characters
187 line.erase(line.begin(), std::ranges::find_if(line, [](int ch) { return std::isgraph(ch); }));
188
189 if (line.empty())
190 {
191 return nullptr;
192 }
193
194 std::istringstream lineStream(line);
195 std::string cell;
196
197 TimeSystem timeSystem = GPST;
198 std::optional<uint16_t> year;
199 std::optional<uint16_t> month;
200 std::optional<uint16_t> day;
201 std::optional<int32_t> hour;
202 std::optional<uint16_t> minute;
203 std::optional<long double> second = 0L;
204 std::optional<uint16_t> gpsWeek;
205 std::optional<long double> gpsToW;
206 Eigen::Vector3d lla_position{ std::nan(""), std::nan(""), std::nan("") };
207 Eigen::Vector3d e_position{ std::nan(""), std::nan(""), std::nan("") };
208 Eigen::Vector3d n_velocity{ std::nan(""), std::nan(""), std::nan("") };
209 Eigen::Vector3d e_velocity{ std::nan(""), std::nan(""), std::nan("") };
210
211 Eigen::Matrix3d e_posVar = Eigen::Matrix3d::Zero() * std::nan("");
212 Eigen::Matrix3d e_velVar = Eigen::Matrix3d::Zero() * std::nan("");
213 Eigen::Matrix3d n_posVar = Eigen::Matrix3d::Zero() * std::nan("");
214 Eigen::Matrix3d n_velVar = Eigen::Matrix3d::Zero() * std::nan("");
215
216 try
217 {
218 for (const auto& column : _headerColumns)
219 {
220 if (lineStream >> cell)
221 {
222 // Remove any trailing non text characters
223 cell.erase(std::ranges::find_if(cell, [](int ch) { return std::iscntrl(ch); }), cell.end());
224 if (cell.empty())
225 {
226 continue;
227 }
228
229 // % GPST latitude(deg) longitude(deg) ...
230 // 2120 216180.000 XX.XXXXXXXXX ...
231 if (column == "GpsWeek")
232 {
233 gpsWeek = static_cast<uint16_t>(std::stoul(cell));
234 }
235 else if (column == "GpsToW")
236 {
237 gpsToW = std::stold(cell);
238 }
239 // % GPST latitude(deg) longitude(deg) ...
240 // 2020/08/25 12:03:00.000 XX.XXXXXXXXX ...
241 // % UTC latitude(deg) longitude(deg) ...
242 // 2020/08/25 12:02:42.000 XX.XXXXXXXXX ...
243 else if (column.starts_with("Date"))
244 {
245 timeSystem = column.ends_with("-GPST") ? GPST : UTC;
246
247 auto ymd = str::split(cell, "/");
248 if (ymd.size() == 3)
249 {
250 year = static_cast<uint16_t>(std::stoi(ymd.at(0)));
251 month = static_cast<uint16_t>(std::stoi(ymd.at(1)));
252 day = static_cast<uint16_t>(std::stoi(ymd.at(2)));
253 }
254 }
255 else if (column.starts_with("Time"))
256 {
257 auto hms = str::split(cell, ":");
258 if (hms.size() == 3)
259 {
260 hour = static_cast<uint16_t>(std::stoi(hms.at(0)));
261 if (column.ends_with("-JST")) { *hour -= 9; }
262 minute = static_cast<uint16_t>(std::stoi(hms.at(1)));
263 second = std::stold(hms.at(2));
264 }
265 }
266 else if (column == "x-ecef(m)" || column == "x-ecef")
267 {
268 e_position.x() = std::stod(cell);
269 }
270 else if (column == "y-ecef(m)" || column == "y-ecef")
271 {
272 e_position.y() = std::stod(cell);
273 }
274 else if (column == "z-ecef(m)" || column == "z-ecef")
275 {
276 e_position.z() = std::stod(cell);
277 }
278 else if (column == "latitude(deg)" || column == "latitude")
279 {
280 lla_position(0) = deg2rad(std::stod(cell));
281 }
282 else if (column == "longitude(deg)" || column == "longitude")
283 {
284 lla_position(1) = deg2rad(std::stod(cell));
285 }
286 else if (column == "height(m)" || column == "height")
287 {
288 lla_position(2) = std::stod(cell);
289 }
290 else if (column == "Q")
291 {
292 obs->Q = static_cast<uint8_t>(std::stoul(cell));
293 }
294 else if (column == "ns")
295 {
296 obs->ns = static_cast<uint8_t>(std::stoul(cell));
297 }
298 else if (column == "sdx(m)" || column == "sdx")
299 {
300 e_posVar(0, 0) = std::pow(std::stod(cell), 2);
301 }
302 else if (column == "sdy(m)" || column == "sdy")
303 {
304 e_posVar(1, 1) = std::pow(std::stod(cell), 2);
305 }
306 else if (column == "sdz(m)" || column == "sdz")
307 {
308 e_posVar(2, 2) = std::pow(std::stod(cell), 2);
309 }
310 else if (column == "sdn(m)" || column == "sdn")
311 {
312 n_posVar(0, 0) = std::pow(std::stod(cell), 2);
313 }
314 else if (column == "sde(m)" || column == "sde")
315 {
316 n_posVar(1, 1) = std::pow(std::stod(cell), 2);
317 }
318 else if (column == "sdu(m)" || column == "sdu")
319 {
320 n_posVar(2, 2) = std::pow(std::stod(cell), 2);
321 }
322 else if (column == "sdxy(m)" || column == "sdxy")
323 {
324 e_posVar(0, 1) = std::stod(cell);
325 e_posVar(0, 1) = gcem::sgn(e_posVar(0, 1)) * std::pow(e_posVar(0, 1), 2);
326 e_posVar(1, 0) = -e_posVar(0, 1);
327 }
328 else if (column == "sdyz(m)" || column == "sdyz")
329 {
330 e_posVar(1, 2) = std::stod(cell);
331 e_posVar(1, 2) = gcem::sgn(e_posVar(1, 2)) * std::pow(e_posVar(1, 2), 2);
332 e_posVar(2, 1) = -e_posVar(1, 2);
333 }
334 else if (column == "sdzx(m)" || column == "sdzx")
335 {
336 e_posVar(2, 0) = std::stod(cell);
337 e_posVar(2, 0) = gcem::sgn(e_posVar(2, 0)) * std::pow(e_posVar(2, 0), 2);
338 e_posVar(0, 2) = -e_posVar(2, 0);
339 }
340 else if (column == "sdne(m)" || column == "sdne")
341 {
342 n_posVar(0, 1) = std::stod(cell);
343 n_posVar(0, 1) = gcem::sgn(n_posVar(0, 1)) * std::pow(n_posVar(0, 1), 2);
344 n_posVar(1, 0) = -n_posVar(0, 1);
345 }
346 else if (column == "sdeu(m)" || column == "sdeu")
347 {
348 n_posVar(1, 2) = std::stod(cell);
349 n_posVar(1, 2) = gcem::sgn(n_posVar(1, 2)) * std::pow(n_posVar(1, 2), 2);
350 n_posVar(2, 1) = -n_posVar(1, 2);
351 }
352 else if (column == "sdun(m)" || column == "sdun")
353 {
354 n_posVar(2, 0) = std::stod(cell);
355 n_posVar(2, 0) = gcem::sgn(n_posVar(2, 0)) * std::pow(n_posVar(2, 0), 2);
356 n_posVar(0, 2) = -n_posVar(2, 0);
357 }
358 else if (column == "age(s)" || column == "age")
359 {
360 obs->age = std::stod(cell);
361 }
362 else if (column == "ratio")
363 {
364 obs->ratio = std::stod(cell);
365 }
366 else if (column == "vn(m/s)" || column == "vn")
367 {
368 n_velocity(0) = std::stod(cell);
369 }
370 else if (column == "ve(m/s)" || column == "ve")
371 {
372 n_velocity(1) = std::stod(cell);
373 }
374 else if (column == "vu(m/s)" || column == "vu")
375 {
376 n_velocity(2) = -std::stod(cell);
377 }
378 else if (column == "vx(m/s)" || column == "vx")
379 {
380 e_velocity(0) = std::stod(cell);
381 }
382 else if (column == "vy(m/s)" || column == "vy")
383 {
384 e_velocity(1) = std::stod(cell);
385 }
386 else if (column == "vz(m/s)" || column == "vz")
387 {
388 e_velocity(2) = std::stod(cell);
389 }
390 else if (column == "sdvn(m/s)" || column == "sdvn")
391 {
392 n_velVar(0, 0) = std::pow(std::stod(cell), 2);
393 }
394 else if (column == "sdve(m/s)" || column == "sdve")
395 {
396 n_velVar(1, 1) = std::pow(std::stod(cell), 2);
397 }
398 else if (column == "sdvu(m/s)" || column == "sdvu")
399 {
400 n_velVar(2, 2) = std::pow(std::stod(cell), 2);
401 }
402 else if (column == "sdvne(m/s)" || column == "sdvne")
403 {
404 n_velVar(0, 1) = std::stod(cell);
405 n_velVar(0, 1) = gcem::sgn(n_velVar(0, 1)) * std::pow(n_velVar(0, 1), 2);
406 n_velVar(1, 0) = -n_velVar(0, 1);
407 }
408 else if (column == "sdveu(m/s)" || column == "sdveu")
409 {
410 n_velVar(1, 2) = std::stod(cell);
411 n_velVar(1, 2) = gcem::sgn(n_velVar(1, 2)) * std::pow(n_velVar(1, 2), 2);
412 n_velVar(2, 1) = -n_velVar(1, 2);
413 }
414 else if (column == "sdvun(m/s)" || column == "sdvun")
415 {
416 n_velVar(2, 0) = std::stod(cell);
417 n_velVar(2, 0) = gcem::sgn(n_velVar(2, 0)) * std::pow(n_velVar(2, 0), 2);
418 n_velVar(0, 2) = -n_velVar(2, 0);
419 }
420 else if (column == "sdvx(m/s)" || column == "sdvx")
421 {
422 e_velVar(0, 0) = std::pow(std::stod(cell), 2);
423 }
424 else if (column == "sdvy(m/s)" || column == "sdvy")
425 {
426 e_velVar(1, 1) = std::pow(std::stod(cell), 2);
427 }
428 else if (column == "sdvz(m/s)" || column == "sdvz")
429 {
430 e_velVar(2, 2) = std::pow(std::stod(cell), 2);
431 }
432 else if (column == "sdvxy(m/s)" || column == "sdvxy")
433 {
434 e_velVar(0, 1) = std::stod(cell);
435 e_velVar(0, 1) = gcem::sgn(e_velVar(0, 1)) * std::pow(e_velVar(0, 1), 2);
436 e_velVar(1, 0) = -e_velVar(0, 1);
437 }
438 else if (column == "sdvyz(m/s)" || column == "sdvyz")
439 {
440 e_velVar(1, 2) = std::stod(cell);
441 e_velVar(1, 2) = gcem::sgn(e_velVar(1, 2)) * std::pow(e_velVar(1, 2), 2);
442 e_velVar(2, 1) = -e_velVar(1, 2);
443 }
444 else if (column == "sdvzx(m/s)" || column == "sdvzx")
445 {
446 e_velVar(2, 0) = std::stod(cell);
447 e_velVar(2, 0) = gcem::sgn(e_velVar(2, 0)) * std::pow(e_velVar(2, 0), 2);
448 e_velVar(0, 2) = -e_velVar(2, 0);
449 }
450 }
451 }
452 }
453 catch (...)
454 {
455 return nullptr;
456 }
457
458 if (gpsWeek.has_value() && gpsToW.has_value())
459 {
460 obs->insTime = InsTime(0, gpsWeek.value(), gpsToW.value());
461 }
462 else if (year.has_value() && month.has_value() && day.has_value()
463 && hour.has_value() && minute.has_value() && second.has_value())
464 {
465 obs->insTime = InsTime(year.value(), month.value(), day.value(),
466 hour.value(), minute.value(), second.value(),
467 timeSystem);
468 }
469
470 if (!e_position.hasNaN()) { obs->setPosition_e(e_position); }
471 else if (!lla_position.hasNaN()) { obs->setPosition_lla(lla_position); }
472
473 if (!e_velocity.hasNaN()) { obs->setVelocity_e(e_velocity); }
474 else if (!n_velocity.hasNaN()) { obs->setVelocity_n(n_velocity); }
475
476 if (!e_velVar.hasNaN() && !e_posVar.hasNaN())
477 {
478 Eigen::Matrix6d cov = Eigen::Matrix6d::Zero(6, 6);
479 cov.block<3, 3>(0, 0) = e_posVar;
480 cov.block<3, 3>(3, 3) = e_velVar;
481 obs->setPosVelCovarianceMatrix_e(cov);
482 }
483 else if (!n_velVar.hasNaN() && !n_posVar.hasNaN())
484 {
485 Eigen::Matrix6d cov = Eigen::Matrix6d::Zero(6, 6);
486 cov.block<3, 3>(0, 0) = n_posVar;
487 cov.block<3, 3>(3, 3) = n_velVar;
488 obs->setPosVelCovarianceMatrix_n(cov);
489 }
490 else if (!e_posVar.hasNaN())
491 {
492 obs->setPosCovarianceMatrix_e(e_posVar);
493 }
494 else if (!n_posVar.hasNaN())
495 {
496 obs->setPosCovarianceMatrix_n(n_posVar);
497 }
498
499 invokeCallbacks(OUTPUT_PORT_INDEX_RTKLIB_POS_OBS, obs);
500 return obs;
501}
502
503NAV::FileReader::FileType NAV::RtklibPosFile::determineFileType()
504{
505 std::filesystem::path filepath = getFilepath();
506
507 auto filestreamHeader = std::ifstream(filepath);
508 if (!filestreamHeader.good())
509 {
510 return FileReader::FileType::NONE;
511 }
512
513 std::string line;
514 do
515 {
516 if (filestreamHeader.eof())
517 {
518 return FileReader::FileType::NONE;
519 }
520
521 std::getline(filestreamHeader, line);
522 // Remove any starting non text characters
523 line.erase(line.begin(), std::ranges::find_if(line, [](int ch) { return std::isgraph(ch); }));
524 } while (!line.empty() && line.find("% ") == std::string::npos);
525
526 return FileReader::FileType::ASCII;
527}
528
529void NAV::RtklibPosFile::readHeader()
530{
531 // Read header line
532 std::string line;
533 do
534 {
535 getline(line);
536 // Remove any starting non text characters
537 line.erase(line.begin(), std::ranges::find_if(line, [](int ch) { return std::isgraph(ch); }));
538 } while (!line.empty() && line.find("% ") == std::string::npos);
539
540 // Convert line into stream
541 std::istringstream lineStream(line);
542
543 for (std::string cell; lineStream >> cell;) // split at 'space'
544 {
545 if (cell != "%")
546 {
547 if (cell == "GPST") // When RTKLIB selected 'ww ssss GPST' or 'hh:mm:ss GPST'
548 {
549 auto pos = tellg();
550 getline(line);
551 seekg(pos, std::ios::beg);
552
553 if (line.substr(0, 7).find('/') == std::string::npos)
554 {
555 // % GPST latitude(deg) longitude(deg) ...
556 // 2120 216180.000 XX.XXXXXXXXX ...
557 _headerColumns.emplace_back("GpsWeek");
558 _headerColumns.emplace_back("GpsToW");
559 }
560 else
561 {
562 // % GPST latitude(deg) longitude(deg) ...
563 // 2020/08/25 12:03:00.000 XX.XXXXXXXXX ...
564 _headerColumns.emplace_back("Date-GPST");
565 _headerColumns.emplace_back("Time-GPST");
566 }
567 }
568 else if (cell == "UTC") // When RTKLIB selected 'hh:mm:ss UTC'
569 {
570 // % UTC latitude(deg) longitude(deg) ...
571 // 2020/08/25 12:02:42.000 XX.XXXXXXXXX ...
572 _headerColumns.emplace_back("Date-UTC");
573 _headerColumns.emplace_back("Time-UTC");
574 }
575 else if (cell == "JST") // When RTKLIB selected 'hh:mm:ss JST'
576 {
577 // % JST latitude(deg) longitude(deg) ...
578 // 2020/08/25 21:02:42.000 XX.XXXXXXXXX ...
579 _headerColumns.emplace_back("Date-JST");
580 _headerColumns.emplace_back("Time-JST");
581 }
582 else
583 {
584 _headerColumns.push_back(cell);
585 }
586 }
587 }
588}
CoordinateFrames.hpp
Transformation collection.
FlowManager.hpp
Save/Load the Nodes.
json
nlohmann::json json
json namespace
Definition FlowManager.hpp:23
Logger.hpp
Utility class for logging to console and file.
LOG_DEBUG
#define LOG_DEBUG
Debug information. Should not be called on functions which receive observations (spamming)
Definition Logger.hpp:67
LOG_TRACE
#define LOG_TRACE
Detailled info to trace the execution of the program. Should not be called on functions which receive...
Definition Logger.hpp:65
RtklibPosFile.hpp
File Reader for RTKLIB Pos files.
RtklibPosObs.hpp
RTKLIB Pos Observation Class.
StringUtil.hpp
Utility functions for working with std::strings.
TimeBase.hpp
Keeps track of the current real/simulation time.
NAV::FileReader::initialize
bool initialize()
Initialize the file reader.
Definition FileReader.cpp:76
NAV::FileReader::restore
void restore(const json &j)
Restores the node from a json object.
Definition FileReader.cpp:66
NAV::FileReader::_path
std::string _path
Path to the file.
Definition FileReader.hpp:155
NAV::FileReader::FileType
FileType
File Type Enumeration.
Definition FileReader.hpp:35
NAV::FileReader::ASCII
@ ASCII
Ascii text data.
Definition FileReader.hpp:38
NAV::FileReader::NONE
@ NONE
Not specified.
Definition FileReader.hpp:36
NAV::FileReader::getFilepath
std::filesystem::path getFilepath()
Returns the path of the file.
Definition FileReader.cpp:44
NAV::FileReader::PATH_CHANGED
@ PATH_CHANGED
The path changed and exists.
Definition FileReader.hpp:56
NAV::FileReader::_headerColumns
std::vector< std::string > _headerColumns
Header Columns of a CSV file.
Definition FileReader.hpp:160
NAV::FileReader::tellg
std::streampos tellg()
Getting the current read position.
Definition FileReader.hpp:138
NAV::FileReader::guiConfig
GuiResult guiConfig(const char *vFilters, const std::vector< std::string > &extensions, size_t id, const std::string &nameId)
ImGui config.
Definition FileReader.cpp:23
NAV::FileReader::resetReader
void resetReader()
Moves the read cursor to the start.
Definition FileReader.cpp:203
NAV::FileReader::getline
auto & getline(std::string &str)
Reads a line from the filestream.
Definition FileReader.hpp:103
NAV::FileReader::save
json save() const
Saves the node into a json object.
Definition FileReader.cpp:55
NAV::FileReader::seekg
auto & seekg(std::streamoff pos, std::ios_base::seekdir dir)
Changing the current read position.
Definition FileReader.hpp:133
NAV::FileReader::deinitialize
void deinitialize()
Deinitialize the file reader.
Definition FileReader.cpp:136
NAV::InsTime
The class is responsible for all time-related tasks.
Definition InsTime.hpp:710
NAV::Node::doDeinitialize
bool doDeinitialize(bool wait=false)
Asks the node worker to deinitialize the node.
Definition Node.cpp:465
NAV::Node::_guiConfigDefaultWindowSize
ImVec2 _guiConfigDefaultWindowSize
Definition Node.hpp:522
NAV::Node::Node
Node(std::string name)
Constructor.
Definition Node.cpp:29
NAV::Node::CreateOutputPin
OutputPin * CreateOutputPin(const char *name, Pin::Type pinType, const std::vector< std::string > &dataIdentifier, OutputPin::PinData data=static_cast< void * >(nullptr), int idx=-1)
Create an Output Pin object.
Definition Node.cpp:278
NAV::Node::nameId
std::string nameId() const
Node name and id.
Definition Node.cpp:323
NAV::Node::name
std::string name
Name of the Node.
Definition Node.hpp:507
NAV::Node::doReinitialize
bool doReinitialize(bool wait=false)
Asks the node worker to reinitialize the node.
Definition Node.cpp:420
NAV::Node::invokeCallbacks
void invokeCallbacks(size_t portIndex, const std::shared_ptr< const NodeData > &data)
Calls all registered callbacks on the specified output port.
Definition Node.cpp:179
NAV::Node::_hasConfig
bool _hasConfig
Flag if the config window should be shown.
Definition Node.hpp:525
NAV::RtklibPosFile::RtklibPosFile
RtklibPosFile()
Default constructor.
Definition RtklibPosFile.cpp:21
NAV::RtklibPosFile::readHeader
void readHeader() override
Read the Header of the file.
Definition RtklibPosFile.cpp:529
NAV::RtklibPosFile::OUTPUT_PORT_INDEX_RTKLIB_POS_OBS
static constexpr size_t OUTPUT_PORT_INDEX_RTKLIB_POS_OBS
Flow (RtklibPosObs)
Definition RtklibPosFile.hpp:62
NAV::RtklibPosFile::typeStatic
static std::string typeStatic()
String representation of the Class Type.
Definition RtklibPosFile.cpp:37
NAV::RtklibPosFile::initialize
bool initialize() override
Initialize the node.
Definition RtklibPosFile.cpp:158
NAV::RtklibPosFile::pollData
std::shared_ptr< const NodeData > pollData()
Polls data from the file.
Definition RtklibPosFile.cpp:179
NAV::RtklibPosFile::determineFileType
FileType determineFileType() override
Determines the type of the file.
Definition RtklibPosFile.cpp:503
NAV::RtklibPosFile::resetNode
bool resetNode() override
Resets the node. Moves the read cursor to the start.
Definition RtklibPosFile.cpp:172
NAV::RtklibPosFile::save
json save() const override
Saves the node into a json object.
Definition RtklibPosFile.cpp:137
NAV::RtklibPosFile::category
static std::string category()
String representation of the Class Category.
Definition RtklibPosFile.cpp:47
NAV::RtklibPosFile::deinitialize
void deinitialize() override
Deinitialize the node.
Definition RtklibPosFile.cpp:165
NAV::RtklibPosFile::~RtklibPosFile
~RtklibPosFile() override
Destructor.
Definition RtklibPosFile.cpp:32
NAV::RtklibPosFile::type
std::string type() const override
String representation of the Class Type.
Definition RtklibPosFile.cpp:42
NAV::RtklibPosFile::restore
void restore(const json &j) override
Restores the node from a json object.
Definition RtklibPosFile.cpp:148
NAV::RtklibPosFile::guiConfig
void guiConfig() override
ImGui config window which is shown on double click.
Definition RtklibPosFile.cpp:52
NAV::RtklibPosObs::type
static std::string type()
Returns the type of the data class.
Definition RtklibPosObs.hpp:139
NAV::TimeSystem
Time System defintions.
Definition TimeSystem.hpp:40
Eigen::Matrix6d
Matrix< double, 6, 6 > Matrix6d
Double 6x6 Eigen::Matrix.
Definition Eigen.hpp:37
NAV::flow::ApplyChanges
void ApplyChanges()
Signals that there have been changes to the flow.
Definition FlowManager.cpp:682
NAV::str::split
static std::vector< std::string > split(const std::string &str, const std::string &delimiter)
Splits a string into parts at a delimiter.
Definition StringUtil.hpp:221
NAV::GPST
@ GPST
GPS Time.
Definition TimeSystem.hpp:30
NAV::UTC
@ UTC
Coordinated Universal Time.
Definition TimeSystem.hpp:29
NAV::deg2rad
constexpr auto deg2rad(const T &deg)
Convert Degree to Radians.
Definition Units.hpp:21
NAV::Pin::Type::Flow
@ Flow
NodeData Trigger.
Definition Pin.hpp:52