Plot.hpp

Go to the documentation of this file.

// 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/.
 
 
#pragma once
 
#include <array>
#include <implot.h>
 
#include <map>
#include <mutex>
#include <unordered_set>
 
#include "internal/Node/Node.hpp"
#include "internal/gui/widgets/DynamicInputPins.hpp"
#include "internal/gui/widgets/PositionInput.hpp"
 
#include "util/Container/ScrollingBuffer.hpp"
#include "util/Container/Vector.hpp"
#include "util/Plot/Colormap.hpp"
#include "util/Logger/CommonLog.hpp"
 
#include "NodeData/General/DynamicData.hpp"
#include "NodeData/GNSS/GnssCombination.hpp"
#include "NodeData/GNSS/GnssObs.hpp"
#include "NodeData/GNSS/RtklibPosObs.hpp"
#include "NodeData/GNSS/SppSolution.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/PosVelAtt.hpp"
#include "NodeData/State/InsGnssTCKFSolution.hpp"
 
namespace NAV
{
class Plot : public Node, public CommonLog
{
  public:
    Plot();
    ~Plot() override;
    Plot(const Plot&) = delete;
    Plot(Plot&&) = delete;
    Plot& operator=(const Plot&) = delete;
    Plot& operator=(Plot&&) = delete;
 
    [[nodiscard]] static std::string typeStatic();
 
    [[nodiscard]] std::string type() const override;
 
    [[nodiscard]] static std::string category();
 
    void guiConfig() override;
 
    [[nodiscard]] json save() const override;
 
    void restore(const json& j) override;
 
    void afterCreateLink(OutputPin& startPin, InputPin& endPin) override;
 
    struct PinData
    {
        struct PlotData
        {
            PlotData() = default;
 
            PlotData(std::string displayName, size_t size);
 
            std::string displayName;
            ScrollingBuffer<double> buffer;
            bool hasData = false;
 
            bool markedForDelete = false;
            bool isDynamic = false;
        };
 
        enum class PinType : int
        {
            Flow,   
            Bool,   
            Int,    
            Float,  
            Matrix, 
        };
 
        PinData() = default;
        ~PinData() = default;
        PinData(const PinData& other);
 
        PinData(PinData&& other) noexcept;
 
        PinData& operator=(const PinData& rhs);
        PinData& operator=(PinData&& rhs) noexcept;
 
        void addPlotDataItem(size_t dataIndex, const std::string& displayName);
 
        int size = 0;
        std::string dataIdentifier;
        std::vector<PlotData> plotData;
        PinType pinType = PinType::Flow;
        int stride = 1;
        std::mutex mutex;
        int dynamicDataStartIndex = -1;
        std::vector<std::tuple<double, InsTime, std::string, int32_t>> events;
    };
 
    struct PlotInfo
    {
        struct PlotItem
        {
            struct Style
            {
                enum class LineType : int
                {
                    Scatter, 
                    Line,    
                };
 
                std::string legendName;
                std::string legendNameGui;
                LineType lineType = LineType::Line;
                ImVec4 color = IMPLOT_AUTO_COL;
                std::pair<ColormapMaskType, int64_t> colormapMask = { ColormapMaskType::None, -1 };
                size_t colormapMaskDataCmpIdx = 0;
                float thickness = 1.0F;
                std::optional<ImPlotLineFlags> lineFlags;
 
                int stride = 0;
 
                std::pair<ColormapMaskType, int64_t> markerColormapMask = { ColormapMaskType::None, -1 };
                size_t markerColormapMaskDataCmpIdx = 0;
                bool markers = false;
                ImPlotMarker markerStyle = ImPlotMarker_Cross;
                float markerSize = 1.0F;
                float markerWeight = 1.0F;
                ImVec4 markerFillColor = IMPLOT_AUTO_COL;
                ImVec4 markerOutlineColor = IMPLOT_AUTO_COL;
 
                bool eventsEnabled = false;
                ImPlotMarker eventMarkerStyle = ImPlotMarker_Cross;
                float eventMarkerSize = 6.0F;
                float eventMarkerWeight = 2.0F;
                ImVec4 eventMarkerFillColor = ImVec4(1.0, 0.0, 0.0, 1.0);
                ImVec4 eventMarkerOutlineColor = ImVec4(1.0, 0.0, 0.0, 1.0);
                std::string eventTooltipFilterRegex;
            };
 
            PlotItem() = default;
 
            PlotItem(size_t pinIndex, size_t dataIndex, std::string displayName)
                : pinIndex(pinIndex), dataIndex(dataIndex), displayName(std::move(displayName))
            {
                style.colormapMaskDataCmpIdx = dataIndex;
                style.markerColormapMaskDataCmpIdx = dataIndex;
            }
 
            PlotItem(size_t pinIndex, size_t dataIndex, std::string displayName, ImAxis axis)
                : PlotItem(pinIndex, dataIndex, std::move(displayName))
            {
                this->axis = axis; // NOLINT(cppcoreguidelines-prefer-member-initializer)
            }
 
            constexpr bool operator==(const PlotItem& rhs) const
            {
                return pinIndex == rhs.pinIndex && dataIndex == rhs.dataIndex && displayName == rhs.displayName;
            }
 
            size_t pinIndex{};        
            size_t dataIndex{};       
            std::string displayName;  
            ImAxis axis{ ImAxis_Y1 }; 
            Style style{};            
            ScrollingBuffer<ImU32> colormapMaskColors = ScrollingBuffer<ImU32>(0);
            size_t colormapMaskVersion = 0;
            ScrollingBuffer<ImU32> markerColormapMaskColors = ScrollingBuffer<ImU32>(0);
            size_t markerColormapMaskVersion = 0;
 
            ScrollingBuffer<double> eventMarker = ScrollingBuffer<double>(0);
 
            struct Tooltip
            {
                InsTime time;                   
                std::vector<std::string> texts; 
            };
            std::vector<std::tuple<double, double, Tooltip>> eventTooltips;
        };
 
        PlotInfo() = default;
 
        PlotInfo(const std::string& title, size_t nInputPins)
            : title(title), headerText(title), selectedXdata(nInputPins, 1) {}
 
        ImVec2 size{ -1, 300 };
 
        std::string title;
        std::string headerText;
        bool overrideXAxisLabel = false;
        std::string xAxisLabel;
        std::string y1AxisLabel;
        std::string y2AxisLabel;
        std::string y3AxisLabel;
        size_t selectedPin = 0;
        int plotFlags = 0;
        ImPlotAxisFlags xAxisFlags = ImPlotAxisFlags_AutoFit;
        ImPlotAxisFlags yAxisFlags = ImPlotAxisFlags_AutoFit;
        ImPlotScale xAxisScale = ImPlotScale_Linear;
        std::array<ImPlotScale, 3> yAxesScale = { ImPlotScale_Linear, ImPlotScale_Linear, ImPlotScale_Linear };
        ImPlotLineFlags lineFlags = ImPlotLineFlags_NoClip | ImPlotLineFlags_SkipNaN;
 
        std::vector<size_t> selectedXdata;
 
        std::vector<PlotItem> plotItems;
 
        float leftPaneWidth = 180.0F;
        float rightPaneWidth = 400.0F;
 
        bool visible = true;
    };
 
  private:
    bool initialize() override;
 
    void deinitialize() override;
 
    void updateNumberOfPlots();
 
    static void pinAddCallback(Node* node);
    static void pinDeleteCallback(Node* node, size_t pinIdx);
 
    size_t GPST_PLOT_IDX = 1;
 
    std::vector<PinData> _pinData;
 
    std::vector<PlotInfo> _plots;
 
    size_t _nPlots = 0;
    std::vector<std::string> _dataIdentifier = {
        // General
        DynamicData::type(),
        // GNSS
        GnssCombination::type(),
        GnssObs::type(),
        RtklibPosObs::type(),
        SppSolution::type(),
        // IMU
        ImuObs::type(),
        ImuObsSimulated::type(),
        ImuObsWDelta::type(),
        KvhObs::type(),
        VectorNavBinaryOutput::type(),
        // State
        InsGnssLCKFSolution::type(),
        Pos::type(),
        PosVel::type(),
        PosVelAtt::type(),
        InsGnssTCKFSolution::type(),
    };
 
    int _dragAndDropHeaderIndex = -1;
 
    std::pair<std::unordered_set<size_t>, ImPlotRange> _forceXaxisRange{};
 
    std::optional<gui::widgets::PositionWithFrame> _originPosition;
 
    bool _overridePositionStartValues = false;
 
    gui::widgets::DynamicInputPins _dynamicInputPins{ 0, this, pinAddCallback, pinDeleteCallback, 1 };
 
    void addEvent(size_t pinIndex, InsTime insTime, const std::string& text, int32_t dataIndex);
 
    void addData(size_t pinIndex, size_t dataIndex, double value);
 
    size_t addData(size_t pinIndex, std::string displayName, double value);
 
    CommonLog::LocalPosition calcLocalPosition(const Eigen::Vector3d& lla_position);
 
    void plotBoolean(const InsTime& insTime, size_t pinIdx);
 
    void plotInteger(const InsTime& insTime, size_t pinIdx);
 
    void plotFloat(const InsTime& insTime, size_t pinIdx);
 
    void plotMatrix(const InsTime& insTime, size_t pinIdx);
 
    void plotFlowData(InputPin::NodeDataQueue& queue, size_t pinIdx);
 
    template<typename T>
    void plotData(const std::shared_ptr<const T>& obs, size_t pinIndex, size_t& plotIndex, size_t startIndex = 0)
    {
        for (size_t i = startIndex; i < T::GetStaticDescriptorCount(); ++i)
        {
            addData(pinIndex, plotIndex++, obs->getValueAtOrNaN(i));
        }
    }
 
    void plotDynamicData(const std::shared_ptr<const DynamicData>& obs, size_t pinIndex, size_t& plotIndex);
 
    void plotGnssCombination(const std::shared_ptr<const GnssCombination>& obs, size_t pinIndex, size_t& plotIndex);
 
    void plotGnssObs(const std::shared_ptr<const GnssObs>& obs, size_t pinIndex, size_t& plotIndex);
 
    void plotSppSolutionDynamicData(const std::shared_ptr<const SppSolution>& obs, size_t pinIndex);
};
 
} // namespace NAV