INSTINCT/NodeRegistry_8cpp_source.html

// This file is part of INSTINCT, the INS Toolkit for Integrated

// Navigation Concepts and Training by the Institute of Navigation of

// the University of Stuttgart, Germany.

//

// This Source Code Form is subject to the terms of the Mozilla Public

// License, v. 2.0. If a copy of the MPL was not distributed with this

// file, You can obtain one at https://mozilla.org/MPL/2.0/.


#include "NodeRegistry.hpp"


#include "util/Logger.hpp"


#include "internal/Node/Node.hpp"

#include "NodeData/NodeData.hpp"


#include <string>


/* -------------------------------------------------------------------------------------------------------- */

/*                                              Private Members                                             */

/* -------------------------------------------------------------------------------------------------------- */


namespace NAV::NodeRegistry

{

namespace

{


/// List of all registered nodes.

/// Key: category, Value: Nodes

std::map<std::string, std::vector<NodeInfo>> _registeredNodes;


/// List of all registered node data types.

/// Key: NodeData.type(), Value: parentTypes()

std::map<std::string, std::vector<std::string>> _registeredNodeDataTypes;


/* -------------------------------------------------------------------------------------------------------- */

/*                                       Private Function Declarations                                      */

/* -------------------------------------------------------------------------------------------------------- */


/// @brief Registers a Node with the NodeManager

/// @tparam T Node Class to register

template<std::derived_from<Node> T>

void registerNodeType()

{

    NodeInfo info;

    info.constructor = []() { return new T(); }; // NOLINT(cppcoreguidelines-owning-memory)

    info.type = T::typeStatic();


    T obj;

    for (const InputPin& pin : obj.inputPins)

    {

        info.pinInfoList.emplace_back(pin.kind, pin.type, pin.dataIdentifier);

    }

    for (const OutputPin& pin : obj.outputPins)

    {

        info.pinInfoList.emplace_back(pin.kind, pin.type, pin.dataIdentifier);

    }


    _registeredNodes[T::category()].push_back(info);

}


/// @brief Register a NodeData with the NodeManager

/// @tparam T NodeData Class to register

template<std::derived_from<NodeData> T>

void registerNodeDataType()

{

    _registeredNodeDataTypes[T::type()] = T::parentTypes();

}


} // namespace

} // namespace NAV::NodeRegistry


/* -------------------------------------------------------------------------------------------------------- */

/*                                           Function Definitions                                           */

/* -------------------------------------------------------------------------------------------------------- */


bool NAV::NodeRegistry::NodeInfo::hasCompatiblePin(const Pin* pin) const

{

    if (pin == nullptr)

    {

        return true;

    }


    Pin::Kind searchPinKind = pin->kind == Pin::Kind::Input ? Pin::Kind::Output : Pin::Kind::Input;

    for (const auto& pinInfo : this->pinInfoList)

    {

        const std::vector<std::string>& startPinDataIdentifier = pin->kind == Pin::Kind::Input ? pinInfo.dataIdentifier : pin->dataIdentifier;

        const std::vector<std::string>& endPinDataIdentifier = pin->kind == Pin::Kind::Input ? pin->dataIdentifier : pinInfo.dataIdentifier;

        const std::string& startPinParentNodeType = pin->kind == Pin::Kind::Input ? this->type : pin->parentNode->type();


        if (pinInfo.kind == searchPinKind && pinInfo.type == pin->type)

        {

            if ((pinInfo.type == Pin::Type::Flow

                 && NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(startPinDataIdentifier, endPinDataIdentifier))

                || (pinInfo.type == Pin::Type::Delegate

                    && std::ranges::find(endPinDataIdentifier, startPinParentNodeType) != endPinDataIdentifier.end())

                || ((pinInfo.type == Pin::Type::Object || pinInfo.type == Pin::Type::Matrix) // NOLINT(misc-redundant-expression) - false positive warning

                    && Pin::dataIdentifierHaveCommon(startPinDataIdentifier, endPinDataIdentifier))

                || pinInfo.type == Pin::Type::Bool || pinInfo.type == Pin::Type::Int || pinInfo.type == Pin::Type::Float || pinInfo.type == Pin::Type::String)

            {

                return true;

            }

        }

    }


    return false;

}


const std::map<std::string, std::vector<NAV::NodeRegistry::NodeInfo>>& NAV::NodeRegistry::RegisteredNodes()

{

    return _registeredNodes;

}


bool NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(const std::vector<std::string>& childTypes, const std::vector<std::string>& parentTypes)

{

    for (const auto& childType : childTypes)

    {

        for (const auto& parentType : parentTypes)

        {

            if (childType == parentType)

            {

                return true;

            }

            for (const auto& [dataType, parentTypes] : _registeredNodeDataTypes)

            {

                if (dataType == childType)

                {

                    for (const auto& parentTypeOfChild : parentTypes)

                    {

                        if (NodeDataTypeAnyIsChildOf({ parentTypeOfChild }, { parentType }))

                        {

                            return true;

                        }

                    }

                }

            }

        }

    }


    return false;

}


std::vector<std::string> NAV::NodeRegistry::GetParentNodeDataTypes(const std::string& type)

{

    std::vector<std::string> returnTypes;

    if (_registeredNodeDataTypes.contains(type))

    {

        const auto& parentTypes = _registeredNodeDataTypes.at(type);


        // Add all the immediate parents

        if (!parentTypes.empty())

        {

            returnTypes.insert(returnTypes.end(), parentTypes.begin(), parentTypes.end());

        }


        // Add parents of parents

        for (const auto& parentType : parentTypes)

        {

            auto parentParentTypes = GetParentNodeDataTypes(parentType);

            if (!parentParentTypes.empty())

            {

                returnTypes.insert(returnTypes.end(), parentParentTypes.begin(), parentParentTypes.end());

            }

        }

    }


    return returnTypes;

}


// Utility

#include "Nodes/Utility/Combiner.hpp"

#include "Nodes/Utility/Demo.hpp"

#include "Nodes/Utility/GroupBox.hpp"

#include "Nodes/Utility/Merger.hpp"

#include "Nodes/Utility/Terminator.hpp"

#include "Nodes/Utility/TimeWindow.hpp"

// Converter

#include "Nodes/Converter/GNSS/RtklibPosConverter.hpp"

#include "Nodes/Converter/GNSS/UartPacketConverter.hpp"

#include "Nodes/Converter/GNSS/UbloxGnssObsConverter.hpp"

#include "Nodes/Converter/GNSS/UbloxGnssOrbitCollector.hpp"

#include "Nodes/Converter/IMU/VectorNavBinaryConverter.hpp"

// Data Link

#if __linux__ || __APPLE__

    #include "Nodes/DataLink/mavlinkSend.hpp"

#endif

#include "Nodes/DataLink/udpSend.hpp"

#include "Nodes/DataLink/udpRecv.hpp"

// Data Logger

#include "Nodes/DataLogger/General/CsvLogger.hpp"

#include "Nodes/DataLogger/General/KmlLogger.hpp"

#include "Nodes/DataLogger/General/MatrixLogger.hpp"

#include "Nodes/DataLogger/GNSS/RinexObsLogger.hpp"

#include "Nodes/DataLogger/GNSS/UartDataLogger.hpp"

#include "Nodes/DataLogger/IMU/VectorNavDataLogger.hpp"

#include "Nodes/DataLogger/WiFi/WiFiObsLogger.hpp"

// Data Processor

#include "Nodes/DataProcessor/ErrorModel/AllanDeviation.hpp"

#include "Nodes/DataProcessor/ErrorModel/ErrorModel.hpp"

#include "Nodes/DataProcessor/GNSS/GnssAnalyzer.hpp"

#include "Nodes/DataProcessor/GNSS/RealTimeKinematic.hpp"

#include "Nodes/DataProcessor/GNSS/SinglePointPositioning.hpp"

#include "Nodes/DataProcessor/Integrator/ImuIntegrator.hpp"

#include "Nodes/DataProcessor/KalmanFilter/LooselyCoupledKF.hpp"

#include "Nodes/DataProcessor/SensorCombiner/ImuFusion.hpp"

#include "Nodes/DataProcessor/WiFi/WiFiPositioning.hpp"

#include "Nodes/DataProcessor/Filter/LowPassFilter.hpp"

#include "Nodes/DataProcessor/Barometer/PressToHgt.hpp"

// Data Provider

#include "Nodes/DataProvider/CSV/CsvFile.hpp"

#include "Nodes/DataProvider/GNSS/FileReader/RinexNavFile.hpp"

#include "Nodes/DataProvider/GNSS/FileReader/RinexObsFile.hpp"

#include "Nodes/DataProvider/GNSS/FileReader/EmlidFile.hpp"

#include "Nodes/DataProvider/GNSS/FileReader/RtklibPosFile.hpp"

#include "Nodes/DataProvider/GNSS/FileReader/NmeaFile.hpp"

#include "Nodes/DataProvider/GNSS/FileReader/UbloxFile.hpp"

#include "Nodes/DataProvider/GNSS/Sensors/EmlidSensor.hpp"

#include "Nodes/DataProvider/GNSS/Sensors/UbloxSensor.hpp"

#include "Nodes/DataProvider/IMU/FileReader/ImuFile.hpp"

#include "Nodes/DataProvider/IMU/FileReader/KvhFile.hpp"

#include "Nodes/DataProvider/IMU/FileReader/VectorNavFile.hpp"

#include "Nodes/DataProvider/IMU/Sensors/KvhSensor.hpp"

#include "Nodes/DataProvider/IMU/Sensors/Navio2Sensor.hpp"

#include "Nodes/DataProvider/IMU/Sensors/VectorNavSensor.hpp"

#include "Nodes/DataProvider/IMU/FileReader/UlogFile.hpp"

#include "Nodes/DataProvider/State/PosVelAttFile.hpp"

#include "Nodes/DataProvider/IMU/FileReader/MultiImuFile.hpp"

#include "Nodes/DataProvider/WiFi/Sensors/EspressifSensor.hpp"

#include "Nodes/DataProvider/WiFi/Sensors/ArubaSensor.hpp"

#include "Nodes/DataProvider/WiFi/FileReader/WiFiObsFile.hpp"

// Data Simulator

#include "Nodes/DataProvider/IMU/Simulators/ImuSimulator.hpp"

#include "Nodes/DataProvider/Barometer/Simulators/BaroSimulator.hpp"

// Plotting

#include "Nodes/Plotting/Plot.hpp"

// State

#include "Nodes/State/PosVelAttInitializer.hpp"

// Experimental

#include "Nodes/Experimental/DataProcessor/ARMA.hpp"

#include "Nodes/Experimental/DataProvider/IMU/NetworkStream/SkydelNetworkStream.hpp"

#include "Nodes/Experimental/Simple/Delay.hpp"


void NAV::NodeRegistry::RegisterNodeTypes()

{

    LOG_TRACE("called");


    Node::_autostartWorker = false;


    // Utility

    registerNodeType<Combiner>();

    registerNodeType<Demo>();

    registerNodeType<GroupBox>();

    registerNodeType<Merger>();

    registerNodeType<Terminator>();

    registerNodeType<TimeWindow>();

    // Converter

    registerNodeType<RtklibPosConverter>();

    registerNodeType<UartPacketConverter>();

    registerNodeType<UbloxGnssObsConverter>();

    registerNodeType<UbloxGnssOrbitCollector>();

    registerNodeType<VectorNavBinaryConverter>();

    // Data Link

#if __linux__ || __APPLE__

    registerNodeType<MavlinkSend>();

#endif

    registerNodeType<UdpSend>();

    registerNodeType<UdpRecv>();

    // Data Logger

    registerNodeType<CsvLogger>();

    registerNodeType<KmlLogger>();

    registerNodeType<MatrixLogger>();

    registerNodeType<RinexObsLogger>();

    registerNodeType<UartDataLogger>();

    registerNodeType<VectorNavDataLogger>();

    registerNodeType<WiFiObsLogger>();

    // Data Processor

    registerNodeType<AllanDeviation>();

    registerNodeType<ErrorModel>();

    registerNodeType<GnssAnalyzer>();

    registerNodeType<RealTimeKinematic>();

    registerNodeType<SinglePointPositioning>();

    registerNodeType<ImuIntegrator>();

    registerNodeType<LooselyCoupledKF>();

    registerNodeType<LowPassFilter>();

    registerNodeType<PressToHgt>();

    registerNodeType<ImuFusion>();

    registerNodeType<WiFiPositioning>();

    // Data Provider

    registerNodeType<CsvFile>();

    registerNodeType<RinexNavFile>();

    registerNodeType<RinexObsFile>();

    registerNodeType<EmlidFile>();

    registerNodeType<RtklibPosFile>();

    registerNodeType<NmeaFile>();

    registerNodeType<UbloxFile>();

    registerNodeType<EmlidSensor>();

    registerNodeType<UbloxSensor>();

    registerNodeType<ImuFile>();

    registerNodeType<KvhFile>();

    registerNodeType<VectorNavFile>();

    registerNodeType<KvhSensor>();

    registerNodeType<Navio2Sensor>();

    registerNodeType<VectorNavSensor>();

    registerNodeType<UlogFile>();

    registerNodeType<PosVelAttFile>();

    registerNodeType<MultiImuFile>();

    registerNodeType<EspressifSensor>();

    registerNodeType<ArubaSensor>();

    registerNodeType<WiFiObsFile>();

    // Data Simulator

    registerNodeType<ImuSimulator>();

    registerNodeType<BaroSimulator>();

    // Experimental

    // registerNodeType<NAV::experimental::ARMA>();

    // registerNodeType<NAV::experimental::SkydelNetworkStream>();

    // registerNodeType<NAV::experimental::Delay>();

    // Plotting

    registerNodeType<Plot>();

    // State

    registerNodeType<PosVelAttInitializer>();


    Node::_autostartWorker = true;

}


#include "NodeData/General/DynamicData.hpp"

#include "NodeData/General/StringObs.hpp"

#include "NodeData/GNSS/EmlidObs.hpp"

#include "NodeData/GNSS/GnssCombination.hpp"

#include "NodeData/GNSS/GnssObs.hpp"

#include "NodeData/GNSS/RtklibPosObs.hpp"

#include "NodeData/GNSS/RtkSolution.hpp"

#include "NodeData/GNSS/SppSolution.hpp"

#include "NodeData/GNSS/UbloxObs.hpp"

#include "NodeData/IMU/ImuObs.hpp"

#include "NodeData/IMU/ImuObsSimulated.hpp"

#include "NodeData/IMU/ImuObsWDelta.hpp"

#include "NodeData/IMU/KvhObs.hpp"

#include "NodeData/IMU/VectorNavBinaryOutput.hpp"

#include "NodeData/State/InsGnssLCKFSolution.hpp"

#include "NodeData/State/InsGnssTCKFSolution.hpp"

#include "NodeData/State/Pos.hpp"

#include "NodeData/State/PosVel.hpp"

#include "NodeData/State/PosVelAtt.hpp"

#include "NodeData/Baro/BaroPressObs.hpp"

#include "NodeData/Baro/BaroHgt.hpp"


#include "NodeData/WiFi/WiFiObs.hpp"

#include "NodeData/WiFi/WiFiPositioningSolution.hpp"


void NAV::NodeRegistry::RegisterNodeDataTypes()

{

    registerNodeDataType<NodeData>();

    // General

    registerNodeDataType<DynamicData>();

    registerNodeDataType<StringObs>();

    // GNSS

    registerNodeDataType<EmlidObs>();

    registerNodeDataType<GnssCombination>();

    registerNodeDataType<GnssObs>();

    registerNodeDataType<RtklibPosObs>();

    registerNodeDataType<RtkSolution>();

    registerNodeDataType<SppSolution>();

    registerNodeDataType<UbloxObs>();

    // IMU

    registerNodeDataType<ImuObs>();

    registerNodeDataType<ImuObsSimulated>();

    registerNodeDataType<ImuObsWDelta>();

    registerNodeDataType<KvhObs>();

    registerNodeDataType<VectorNavBinaryOutput>();

    // State

    registerNodeDataType<InsGnssLCKFSolution>();

    registerNodeDataType<Pos>();

    registerNodeDataType<PosVel>();

    registerNodeDataType<PosVelAtt>();

    // WiFi

    registerNodeDataType<WiFiObs>();

    registerNodeDataType<WiFiPositioningSolution>();

    // Barometer

    registerNodeDataType<BaroPressObs>();

    registerNodeDataType<BaroHgt>();

}


std::vector<std::string> NAV::NodeRegistry::GetStaticDataDescriptors(const std::vector<std::string>& dataIdentifier)

{

    // ATTENTION: Entries need to be in correct inheritance order (deepest inheritance first)


    // NodeData

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { DynamicData::type() })) { return DynamicData::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { StringObs::type() })) { return StringObs::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { GnssCombination::type() })) { return GnssCombination::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { GnssObs::type() })) { return GnssObs::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { VectorNavBinaryOutput::type() })) { return VectorNavBinaryOutput::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { EmlidObs::type() })) { return EmlidObs::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { UbloxObs::type() })) { return UbloxObs::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { WiFiObs::type() })) { return WiFiObs::GetStaticDataDescriptors(); }

    // Pos

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { InsGnssTCKFSolution::type() })) { return InsGnssTCKFSolution::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { InsGnssLCKFSolution::type() })) { return InsGnssLCKFSolution::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { PosVelAtt::type() })) { return PosVelAtt::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { RtkSolution::type() })) { return RtkSolution::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { SppSolution::type() })) { return SppSolution::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { RtklibPosObs::type() })) { return RtklibPosObs::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { WiFiPositioningSolution::type() })) { return WiFiPositioningSolution::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { PosVel::type() })) { return PosVel::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { Pos::type() })) { return Pos::GetStaticDataDescriptors(); }

    // ImuObs

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { ImuObsSimulated::type() })) { return ImuObsSimulated::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { ImuObsWDelta::type() })) { return ImuObsWDelta::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { KvhObs::type() })) { return KvhObs::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { ImuObs::type() })) { return ImuObs::GetStaticDataDescriptors(); }

    // Barometer

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { BaroPressObs::type() })) { return BaroPressObs::GetStaticDataDescriptors(); }

    if (NAV::NodeRegistry::NodeDataTypeAnyIsChildOf(dataIdentifier, { BaroHgt::type() })) { return BaroHgt::GetStaticDataDescriptors(); }


    return {};

}


bool NAV::NodeRegistry::TypeHasDynamicData(const std::string& type)

{

    return type == DynamicData::type()

           || type == GnssCombination::type()

           || type == GnssObs::type()

           || type == RtkSolution::type()

           || type == SppSolution::type()

           || type == VectorNavBinaryOutput::type();

}


std::shared_ptr<NAV::NodeData> NAV::NodeRegistry::CopyNodeData(const std::shared_ptr<const NodeData>& nodeData)

{

    if (nodeData == nullptr) { return nullptr; }


    // General

    if (nodeData->getType() == DynamicData::type()) { return std::make_shared<DynamicData>(*std::static_pointer_cast<const DynamicData>(nodeData)); }

    if (nodeData->getType() == StringObs::type()) { return std::make_shared<StringObs>(*std::static_pointer_cast<const StringObs>(nodeData)); }

    // GNSS

    if (nodeData->getType() == EmlidObs::type()) { return std::make_shared<EmlidObs>(*std::static_pointer_cast<const EmlidObs>(nodeData)); }

    if (nodeData->getType() == GnssCombination::type()) { return std::make_shared<GnssCombination>(*std::static_pointer_cast<const GnssCombination>(nodeData)); }

    if (nodeData->getType() == GnssObs::type()) { return std::make_shared<GnssObs>(*std::static_pointer_cast<const GnssObs>(nodeData)); }

    if (nodeData->getType() == RtklibPosObs::type()) { return std::make_shared<RtklibPosObs>(*std::static_pointer_cast<const RtklibPosObs>(nodeData)); }

    if (nodeData->getType() == RtkSolution::type()) { return std::make_shared<RtkSolution>(*std::static_pointer_cast<const RtkSolution>(nodeData)); }

    if (nodeData->getType() == SppSolution::type()) { return std::make_shared<SppSolution>(*std::static_pointer_cast<const SppSolution>(nodeData)); }

    if (nodeData->getType() == UbloxObs::type()) { return std::make_shared<UbloxObs>(*std::static_pointer_cast<const UbloxObs>(nodeData)); }

    // IMU

    if (nodeData->getType() == ImuObs::type()) { return std::make_shared<ImuObs>(*std::static_pointer_cast<const ImuObs>(nodeData)); }

    if (nodeData->getType() == ImuObsSimulated::type()) { return std::make_shared<ImuObsSimulated>(*std::static_pointer_cast<const ImuObsSimulated>(nodeData)); }

    if (nodeData->getType() == ImuObsWDelta::type()) { return std::make_shared<ImuObsWDelta>(*std::static_pointer_cast<const ImuObsWDelta>(nodeData)); }

    if (nodeData->getType() == KvhObs::type()) { return std::make_shared<KvhObs>(*std::static_pointer_cast<const KvhObs>(nodeData)); }

    if (nodeData->getType() == VectorNavBinaryOutput::type()) { return std::make_shared<VectorNavBinaryOutput>(*std::static_pointer_cast<const VectorNavBinaryOutput>(nodeData)); }

    // State

    if (nodeData->getType() == InsGnssLCKFSolution::type()) { return std::make_shared<InsGnssLCKFSolution>(*std::static_pointer_cast<const InsGnssLCKFSolution>(nodeData)); }

    if (nodeData->getType() == InsGnssTCKFSolution::type()) { return std::make_shared<InsGnssTCKFSolution>(*std::static_pointer_cast<const InsGnssTCKFSolution>(nodeData)); }

    if (nodeData->getType() == Pos::type()) { return std::make_shared<Pos>(*std::static_pointer_cast<const Pos>(nodeData)); }

    if (nodeData->getType() == PosVel::type()) { return std::make_shared<PosVel>(*std::static_pointer_cast<const PosVel>(nodeData)); }

    if (nodeData->getType() == PosVelAtt::type()) { return std::make_shared<PosVelAtt>(*std::static_pointer_cast<const PosVelAtt>(nodeData)); }

    // WiFi

    if (nodeData->getType() == WiFiObs::type()) { return std::make_shared<WiFiObs>(*std::static_pointer_cast<const WiFiObs>(nodeData)); }

    if (nodeData->getType() == WiFiPositioningSolution::type()) { return std::make_shared<WiFiPositioningSolution>(*std::static_pointer_cast<const WiFiPositioningSolution>(nodeData)); }

    // Barometer

    if (nodeData->getType() == BaroPressObs::type()) { return std::make_shared<BaroPressObs>(*std::static_pointer_cast<const BaroPressObs>(nodeData)); }

    if (nodeData->getType() == BaroHgt::type()) { return std::make_shared<BaroHgt>(*std::static_pointer_cast<const BaroHgt>(nodeData)); }


    return nullptr;

}


ARMA.hpp
ARMA Node.

AllanDeviation.hpp
Computes Allan Deviation.

ArubaSensor.hpp
Aruba Sensor Class.

BaroHgt.hpp
Barometric Height Storage Class.

BaroPressObs.hpp
Barometric Pressure Storage Class.

BaroSimulator.hpp
Barometer observation simulator.

Combiner.hpp
Calculates differences between signals.

CsvFile.hpp
CSV File reader.

CsvLogger.hpp
Data Logger for CSV files.

Delay.hpp
Delay Node.

Demo.hpp
Demo Node which demonstrates all capabilities.

DynamicData.hpp
Dynamic Data container.

EmlidFile.hpp
File Reader for Emlid log files.

EmlidObs.hpp
Emlid Observation Class.

EmlidSensor.hpp
Emlid Sensor Class.

ErrorModel.hpp
Adds errors (biases and noise) to measurements.

EspressifSensor.hpp
Espressif Sensor Class.

GnssAnalyzer.hpp
Allows creation of GNSS measurement combinations.

GnssCombination.hpp
GNSS measurement combinations.

GnssObs.hpp
GNSS Observation messages.

GroupBox.hpp
Group Box.

ImuFile.hpp
File Reader for Imu log files.

ImuFusion.hpp
Combines signals of sensors that provide the same signal-type to one signal.

ImuIntegrator.hpp
Integrates ImuObs Data.

ImuObsSimulated.hpp
Data storage class for simulated IMU observations.

ImuObsWDelta.hpp
Data storage class for one VectorNavImu observation.

ImuObs.hpp
Parent Class for all IMU Observations.

ImuSimulator.hpp
Imu Observation Simulator.

InsGnssLCKFSolution.hpp
Loosely-coupled Kalman Filter INS/GNSS errors.

InsGnssTCKFSolution.hpp
Tightly-coupled Kalman Filter INS/GNSS errors.

KmlLogger.hpp
Data Logger for Pos data as KML (Keyhole Markup Language) files (input for Google Earth)

KvhFile.hpp
File Reader for Kvh log files.

KvhObs.hpp
Data storage class for one KVH Imu observation.

KvhSensor.hpp
KVH Sensors.

Logger.hpp
Utility class for logging to console and file.

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

LooselyCoupledKF.hpp
Kalman Filter class for the loosely coupled INS/GNSS integration.

LowPassFilter.hpp
Filters incoming data.

MatrixLogger.hpp
Data Logger for matrices.

Merger.hpp
Merger Node.

MultiImuFile.hpp
File reader for Multi-IMU data log files.

Navio2Sensor.hpp
Navio2 Sensors.

NmeaFile.hpp
File Reader for NMEA files.

NodeData.hpp
Abstract NodeData Class.

NodeRegistry.hpp
Utility class which specifies available nodes.

Node.hpp
Node Class.

Plot.hpp
Plots data into ImPlot Windows.

PosVelAttFile.hpp
PosVelAtt File Reader.

PosVelAttInitializer.hpp
Position, Velocity, Attitude Initializer from GPS and IMU data.

PosVelAtt.hpp
Position, Velocity and Attitude Storage Class.

PosVel.hpp
Position and Velocity Storage Class.

Pos.hpp
Position Storage Class.

PressToHgt.hpp
Pressure to height converter.

RealTimeKinematic.hpp
Real-Time Kinematic (RTK) carrier-phase DGNSS.

RinexNavFile.hpp
File reader for RINEX Navigation messages.

RinexObsFile.hpp
File reader for RINEX Observation messages.

RinexObsLogger.hpp
Logger for GnssObs to RINEX observation files.

RtkSolution.hpp
RTK Node/Algorithm output.

RtklibPosConverter.hpp
Convert RTKLib pos files into PosVel.

RtklibPosFile.hpp
File Reader for RTKLIB Pos files.

RtklibPosObs.hpp
RTKLIB Pos Observation Class.

SinglePointPositioning.hpp
Single Point Positioning (SPP) / Code Phase Positioning.

SkydelNetworkStream.hpp
Node receiving UDP packages from the Skydel GNSS simulator Instinct plugin.

SppSolution.hpp
SPP Algorithm output.

StringObs.hpp
Wrapper for String Messages.

Terminator.hpp
Terminator for open signals. Mainly used for test flows.

TimeWindow.hpp
Limits measurement data from any source to a user-defined timewindow.

UartDataLogger.hpp
Data Logger for Uart packets.

UartPacketConverter.hpp
Decrypts Uart packets.

UbloxFile.hpp
File Reader for ubx files.

UbloxGnssObsConverter.hpp
Convert UbloxObs into GnssObs.

UbloxGnssOrbitCollector.hpp
Collects UBX-RXM-SFRBX messages and provides the Orbit information.

UbloxObs.hpp
ublox Observation Class

UbloxSensor.hpp
Ublox Sensor Class.

UlogFile.hpp
File Reader for ULog files.

VectorNavBinaryConverter.hpp
Converts VectorNavBinaryOutput.

VectorNavBinaryOutput.hpp
Binary Outputs from VectorNav Sensors.

VectorNavDataLogger.hpp
Data Logger for VectorNav observations.

VectorNavFile.hpp
File Reader for Vector Nav log files.

VectorNavSensor.hpp
Vector Nav Sensors.

WiFiObsFile.hpp
WiFiObs File Reader.

WiFiObsLogger.hpp
Data Logger for WiFi observations.

WiFiObs.hpp
Espressif Observation Class.

WiFiPositioningSolution.hpp
WiFi Positioning Algorithm output.

WiFiPositioning.hpp
WiFi Positioning.

NAV::BaroHgt::type
static std::string type()
Returns the type of the data class.
Definition BaroHgt.hpp:28

NAV::BaroHgt::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition BaroHgt.hpp:45

NAV::BaroPressObs::type
static std::string type()
Returns the type of the data class.
Definition BaroPressObs.hpp:27

NAV::BaroPressObs::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition BaroPressObs.hpp:44

NAV::DynamicData::type
static std::string type()
Returns the type of the data class.
Definition DynamicData.hpp:30

NAV::EmlidObs::type
static std::string type()
Returns the type of the data class.
Definition EmlidObs.hpp:30

NAV::GnssCombination::type
static std::string type()
Returns the type of the data class.
Definition GnssCombination.hpp:32

NAV::GnssObs::type
static std::string type()
Returns the type of the data class.
Definition GnssObs.hpp:150

NAV::ImuObsSimulated::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition ImuObsSimulated.hpp:50

NAV::ImuObsSimulated::type
static std::string type()
Returns the type of the data class.
Definition ImuObsSimulated.hpp:31

NAV::ImuObsWDelta::type
static std::string type()
Returns the type of the data class.
Definition ImuObsWDelta.hpp:32

NAV::ImuObsWDelta::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition ImuObsWDelta.hpp:49

NAV::ImuObs::type
static std::string type()
Returns the type of the data class.
Definition ImuObs.hpp:33

NAV::ImuObs::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition ImuObs.hpp:50

NAV::InsGnssLCKFSolution::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition InsGnssLCKFSolution.hpp:49

NAV::InsGnssLCKFSolution::type
static std::string type()
Returns the type of the data class.
Definition InsGnssLCKFSolution.hpp:30

NAV::InsGnssTCKFSolution::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition InsGnssTCKFSolution.hpp:45

NAV::InsGnssTCKFSolution::type
static std::string type()
Returns the type of the data class.
Definition InsGnssTCKFSolution.hpp:26

NAV::KvhObs::type
static std::string type()
Returns the type of the data class.
Definition KvhObs.hpp:39

NAV::KvhObs::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition KvhObs.hpp:56

NAV::NodeData::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition NodeData.hpp:56

NAV::Node::_autostartWorker
static bool _autostartWorker
Flag which prevents the worker to be autostarted if false.
Definition Node.hpp:451

NAV::Node::type
virtual std::string type() const =0
String representation of the Class Type.

NAV::Pin
Pins in the GUI for information exchange.
Definition Pin.hpp:43

NAV::Pin::parentNode
Node * parentNode
Reference to the parent node.
Definition Pin.hpp:307

NAV::Pin::dataIdentifier
std::vector< std::string > dataIdentifier
One or multiple Data Identifiers (Unique name which is used for data flows)
Definition Pin.hpp:305

NAV::Pin::type
Type type
Type of the Pin.
Definition Pin.hpp:301

NAV::Pin::dataIdentifierHaveCommon
static bool dataIdentifierHaveCommon(const std::vector< std::string > &a, const std::vector< std::string > &b)
Checks if the first list of data identifiers has a common entry with the second.
Definition Pin.cpp:59

NAV::Pin::kind
Kind kind
Kind of the Pin (Input/Output)
Definition Pin.hpp:303

NAV::PosVelAtt::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition PosVelAtt.hpp:48

NAV::PosVelAtt::type
static std::string type()
Returns the type of the data class.
Definition PosVelAtt.hpp:29

NAV::PosVel::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition PosVel.hpp:46

NAV::PosVel::type
static std::string type()
Returns the type of the data class.
Definition PosVel.hpp:27

NAV::Pos::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition Pos.hpp:53

NAV::Pos::type
static std::string type()
Returns the type of the data class.
Definition Pos.hpp:36

NAV::RtkSolution::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition RtkSolution.hpp:61

NAV::RtkSolution::type
static std::string type()
Returns the type of the data class.
Definition RtkSolution.hpp:42

NAV::RtklibPosObs::type
static std::string type()
Returns the type of the data class.
Definition RtklibPosObs.hpp:139

NAV::RtklibPosObs::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition RtklibPosObs.hpp:158

NAV::SppSolution::type
static std::string type()
Returns the type of the data class.
Definition SppSolution.hpp:41

NAV::SppSolution::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition SppSolution.hpp:60

NAV::StringObs::type
static std::string type()
Returns the type of the data class.
Definition StringObs.hpp:33

NAV::UbloxObs::type
static std::string type()
Returns the type of the data class.
Definition UbloxObs.hpp:30

NAV::VectorNavBinaryOutput::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition VectorNavBinaryOutput.hpp:65

NAV::VectorNavBinaryOutput::type
static std::string type()
Returns the type of the data class.
Definition VectorNavBinaryOutput.hpp:48

NAV::WiFiObs::type
static std::string type()
Returns the type of the data class.
Definition WiFiObs.hpp:27

NAV::WiFiPositioningSolution::GetStaticDataDescriptors
static std::vector< std::string > GetStaticDataDescriptors()
Returns a vector of data descriptors.
Definition WiFiPositioningSolution.hpp:48

NAV::WiFiPositioningSolution::type
static std::string type()
Returns the type of the data class.
Definition WiFiPositioningSolution.hpp:29

mavlinkSend.hpp
Sends a navigation solution via the MAVLink protocol.

NAV::NodeRegistry
Definition Node.hpp:51

NAV::NodeRegistry::NodeDataTypeAnyIsChildOf
bool NodeDataTypeAnyIsChildOf(const std::vector< std::string > &childTypes, const std::vector< std::string > &parentTypes)
Checks if any of the provided child types is a child of any of the provided parent types.
Definition NodeRegistry.cpp:113

NAV::NodeRegistry::RegisteredNodes
const std::map< std::string, std::vector< NodeInfo > > & RegisteredNodes()
Reference to List of all registered Nodes.
Definition NodeRegistry.cpp:108

NAV::NodeRegistry::GetParentNodeDataTypes
std::vector< std::string > GetParentNodeDataTypes(const std::string &type)
Get the Parent Node Data Types of the specified Node Data Type.
Definition NodeRegistry.cpp:142

NAV::NodeRegistry::RegisterNodeDataTypes
void RegisterNodeDataTypes()
Register all available NodeData types for the program.
Definition NodeRegistry.cpp:349

NAV::NodeRegistry::TypeHasDynamicData
bool TypeHasDynamicData(const std::string &type)
Wether the specified Node Data Type can have dynamic data.
Definition NodeRegistry.cpp:417

NAV::NodeRegistry::RegisterNodeTypes
void RegisterNodeTypes()
Register all available Node types for the program.
Definition NodeRegistry.cpp:242

NAV::NodeRegistry::GetStaticDataDescriptors
std::vector< std::string > GetStaticDataDescriptors(const std::vector< std::string > &dataIdentifier)
Returns a vector of data descriptors for the pin data identifiers.
Definition NodeRegistry.cpp:382

NAV::NodeRegistry::CopyNodeData
std::shared_ptr< NodeData > CopyNodeData(const std::shared_ptr< const NodeData > &nodeData)
Creates a copy of the data.
Definition NodeRegistry.cpp:427

NAV::NodeRegistry::NodeInfo
Holds information for registered nodes.
Definition NodeRegistry.hpp:50

NAV::NodeRegistry::NodeInfo::constructor
std::function< Node *()> constructor
Constructor.
Definition NodeRegistry.hpp:52

NAV::NodeRegistry::NodeInfo::type
std::string type
Class Type of the node.
Definition NodeRegistry.hpp:54

NAV::NodeRegistry::NodeInfo::hasCompatiblePin
bool hasCompatiblePin(const Pin *pin) const
Checks if the node has a pin which can be linked.
Definition NodeRegistry.cpp:76

NAV::NodeRegistry::NodeInfo::pinInfoList
std::vector< PinInfo > pinInfoList
List of port data types.
Definition NodeRegistry.hpp:56

NAV::Pin::Kind
Kind of the Pin (Input/Output)
Definition Pin.hpp:165

NAV::Pin::Kind::Input
@ Input
Input Pin.
Definition Pin.hpp:171

NAV::Pin::Kind::Output
@ Output
Output Pin.
Definition Pin.hpp:170

NAV::Pin::Type::Delegate
@ Delegate
Reference to the Node object.
Definition Pin.hpp:59

NAV::Pin::Type::Matrix
@ Matrix
Matrix Object.
Definition Pin.hpp:58

NAV::Pin::Type::Int
@ Int
Integer Number.
Definition Pin.hpp:54

NAV::Pin::Type::Float
@ Float
Floating Point Number.
Definition Pin.hpp:55

NAV::Pin::Type::String
@ String
std::string
Definition Pin.hpp:56

NAV::Pin::Type::Flow
@ Flow
NodeData Trigger.
Definition Pin.hpp:52

NAV::Pin::Type::Bool
@ Bool
Boolean.
Definition Pin.hpp:53

NAV::Pin::Type::Object
@ Object
Generic Object.
Definition Pin.hpp:57

udpRecv.hpp
Asynchronous data link - receiver node.

udpSend.hpp
Asynchronous data link - sender node.