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 <imgui.h>
#include <implot.h>
 
#include <map>
#include <memory>
#include <mutex>
#include <unordered_set>
 
#include "NodeData/NodeData.hpp"
#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/PlotEventTooltip.hpp"
#include "util/Plot/PlotItemStyle.hpp"
#include "util/Plot/PlotTooltip.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"
#include "NodeData/WiFi/WiFiPositioningSolution.hpp"
#include "NodeData/Baro/BaroPressObs.hpp"
#include "NodeData/Baro/BaroHgt.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 : uint8_t
        {
            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;
        ScrollingBuffer<std::shared_ptr<const NodeData>> rawNodeData;
        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
        {
            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 }; 
            PlotItemStyle 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);

            std::array<ScrollingBuffer<double>, 2> errorBoundsData;

            std::vector<std::tuple<double, double, PlotEventTooltip>> 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;

        std::vector<PlotTooltip> tooltips;
    };
 
  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(),
        // WiFi
        WiFiPositioningSolution::type(),
        // Barometer
        BaroHgt::type(),
        BaroPressObs::type(),
 
    };

    int _dragAndDropHeaderIndex = -1;
 
    size_t _screenshotFrameCnt = 0; 
    size_t _screenShotPlotIdx = 0;  

    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));
        }
    }
};
 
} // namespace NAV