RADPlot.h

Go to the documentation of this file.

#ifndef RADPLOT_H
#define RADPLOT_H
 
#pragma once
 
#include <RADUi/RADUi.h>
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace RADUi {
 
    struct PlotPoint {
        double x = 0.0;
        double y = 0.0;
    };
 
    struct PlotColor {
        uint8_t r = 255;
        uint8_t g = 255;
        uint8_t b = 255;
        uint8_t a = 255;
    };
 
    struct PlotRange {
        double min = 0.0;
        double max = 1.0;
    };
 
    struct PlotSeriesStyle {
        PlotColor color{33, 150, 243, 255};
        int lineWidth = 1;
        bool drawLines = true;
        bool drawPoints = false;
    };
 
    struct PlotSeriesSnapshot {
        std::string name;
        PlotSeriesStyle style;
        std::vector<PlotPoint> points;
    };
 
    struct PlotModelSnapshot {
        std::vector<PlotSeriesSnapshot> series;
        PlotRange xRange;
        PlotRange yRange;
        bool hasData = false;
    };
 
    enum class PlotAxisFormat {
        Numeric,
        SecondsMilliseconds,
        LogFrequencyHz
    };
 
    enum class PlotTickMode {
        EvenlySpaced,
        FixedInterval
    };
 
    enum class PlotAxisLabelMode {
        AxisValue,
        WindowRelative
    };
 
    struct PlotViewport {
        int width = 640;
        int height = 320;
        int leftMargin = 48;
        int rightMargin = 16;
        int topMargin = 16;
        int bottomMargin = 32;
        int xTickCount = 5;
        int yTickCount = 5;
        bool drawXAxisLabels = false;
        PlotAxisFormat xAxisFormat = PlotAxisFormat::Numeric;
        PlotTickMode xTickMode = PlotTickMode::EvenlySpaced;
        double xTickInterval = 1.0;
        PlotAxisLabelMode xAxisLabelMode = PlotAxisLabelMode::WindowRelative;
    };
 
    struct PlotPixel {
        uint8_t r = 0;
        uint8_t g = 0;
        uint8_t b = 0;
        uint8_t a = 255;
    };
 
    struct PlotImage {
        int width = 0;
        int height = 0;
        std::vector<PlotPixel> pixels;
    };
 
    enum class PlotRenderMode {
        Software,
        OpenGL
    };
 
    class PlotModel : public RADCore::RADObject {
    public:
        RADEvents:
            RAD_EVENT(dataChanged, ());
 
        PlotModel();
        ~PlotModel() override;
 
        size_t addSeries(std::string name, PlotSeriesStyle style = {});
        size_t seriesCount() const;
        void clear();
        void clearSeries(size_t seriesIndex);
 
        void append(size_t seriesIndex, double x, double y);
        void append(size_t seriesIndex, PlotPoint point);
        void appendBatch(size_t seriesIndex, const std::vector<PlotPoint>& points);
 
        void setMaxPointCount(size_t maxPointCount);
        size_t maxPointCount() const;
 
        void setRollingXWindow(double width);
        double rollingXWindow() const;
 
        void setAutoRange(bool enabled);
        bool autoRange() const;
        void setXRange(PlotRange range);
        void setYRange(PlotRange range);
        PlotRange xRange() const;
        PlotRange yRange() const;
 
        void setSeriesStyle(size_t seriesIndex, PlotSeriesStyle style);
        PlotModelSnapshot snapshot() const;
 
    private:
        struct Series;
        struct Impl;
        std::unique_ptr<Impl> pImpl_;
    };
 
    class QuadPlotModel {
    public:
        QuadPlotModel();
 
        PlotModel& panel(size_t index);
        const PlotModel& panel(size_t index) const;
        void setSharedRollingXWindow(double width);
        void setMaxPointCount(size_t maxPointCount);
        void clear();
 
    private:
        std::array<std::shared_ptr<PlotModel>, 4> panels_;
    };
 
    class PlotRenderer {
    public:
        virtual ~PlotRenderer() = default;
        virtual PlotImage render(const PlotModelSnapshot& snapshot, const PlotViewport& viewport) = 0;
    };
 
    class SoftwarePlotRenderer final : public PlotRenderer {
    public:
        PlotImage render(const PlotModelSnapshot& snapshot, const PlotViewport& viewport) override;
 
    private:
        PlotColor background_{18, 22, 26, 255};
        PlotColor plotArea_{24, 30, 36, 255};
        PlotColor grid_{55, 65, 75, 255};
        PlotColor axis_{150, 160, 170, 255};
    };
 
    class OpenGLPlotRenderer final : public PlotRenderer {
    public:
        PlotImage render(const PlotModelSnapshot& snapshot, const PlotViewport& viewport) override;
 
    private:
        SoftwarePlotRenderer fallback_;
    };
 
    std::unique_ptr<PlotRenderer> createPlotRenderer(PlotRenderMode mode);
 
} // namespace RADUi
 
#endif