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