CuiPlot.hh

[詳解]

 
//
// Copyright (C) 2011-2020 Yokokura, Yuki
// This program is free software;
// you can redistribute it and/or modify it under the terms of the FreeBSD License.
// For details, see the License.txt file.
 
#ifndef CUIPLOT
#define CUIPLOT
 
#include <cassert>
#include <cstdint>
#include <memory>
#include "FrameGraphics.hh"
#include "RingBuffer.hh"
#include "Matrix.hh"
 
// ARCS組込み用マクロ
#ifdef ARCS_IN
    // ARCSに組み込まれる場合
    #include "ARCSassert.hh"
    #include "ARCSeventlog.hh"
#else
    // ARCSに組み込まれない場合
    #define arcs_assert(a) (assert(a))
    #define PassedLog()
    #define EventLog(a)
    #define EventLogVar(a)
#endif
 
namespace ARCS {    // ARCS名前空間
 
enum class CuiPlotTypes {
    PLOT_LINE,      
    PLOT_BOLDLINE,  
    PLOT_DOT,       
    PLOT_BOLDDOT,   
    PLOT_CROSS,     
    PLOT_STAIRS,    
    PLOT_BOLDSTAIRS,
    PLOT_LINEANDDOT,
};
 
class CuiPlot {
    public:
        CuiPlot(FrameGraphics& Frame, int Left, int Top, int Width, int Height) :
            LEFT(Left),
            TOP(Top),
            WIDTH(Width),
            HEIGHT(Height),
            PLOT_LEFT(LEFT + 3*MARGIN_WIDTH/2),
            PLOT_TOP(TOP + MARGIN_TOP),
            PLOT_WIDTH(WIDTH - MARGIN_WIDTH_X2),
            PLOT_HEIGHT(HEIGHT - MARGIN_TOP - MARGIN_BOTTOM),
            FG(Frame),
            AxisColor(FGcolors::WHITE),
            GridColor(FGcolors::GRAY25),
            TextColor(FGcolors::WHITE),
            BackColor(FGcolors::BLACK),
            CursorColor(FGcolors::GRAY50),
            Xmax(1),
            Xmin(-1),
            Ymax(1),
            Ymin(-1),
            Xwidth(Xmax - Xmin),
            Yheight(Ymax - Ymin),
            Xgrid({0}),
            Ygrid({0}),
            XgridNum(4),
            YgridNum(4),
            Xform("%1.1f"),
            Yform("%1.1f"),
            Xlabel("X AXIS [unit]"),
            Ylabel("Y AXIS [unit]"),
            VisibleFlag(true)
        {
            PassedLog();
            CalcGridNumbers();  // グリッド数値の計算
        }
        
        CuiPlot(CuiPlot&& r) = delete;
            // :
        //{
            
        //}
        
        ~CuiPlot(){
            PassedLog();
        }
        
        void SetColors(FGcolors Axis, FGcolors Grid, FGcolors Text, FGcolors Back, FGcolors Cursor){
            AxisColor = Axis;
            GridColor = Grid;
            TextColor = Text;
            BackColor = Back;
            CursorColor = Cursor;
            FG.PrepareFontData(TextColor, BackColor);   // 指定色のフォントデータの準備
        }
        
        void SetRanges(double xmin, double xmax, double ymin, double ymax){
            arcs_assert(xmin < xmax);
            arcs_assert(ymin < ymax);
            Xmin = xmin;
            Xmax = xmax;
            Ymin = ymin;
            Ymax = ymax;
            Xwidth = Xmax - Xmin;
            Yheight = Ymax - Ymin;
            CalcGridNumbers();      // グリッド数値の再計算
        }
        
        void SetAxisLabels(const std::string& xlabel, const std::string& ylabel){
            Xlabel = xlabel;
            Ylabel = ylabel;
        }
        
        void SetGridLabelFormat(const std::string& xformat, const std::string& yformat){
            Xform = xformat;
            Yform = yformat;
        }
        
        void SetGridDivision(size_t xdiv, size_t ydiv){
            arcs_assert(xdiv < XGRID_MAX);
            arcs_assert(ydiv < YGRID_MAX);
            XgridNum = xdiv;
            YgridNum = ydiv;
            CalcGridNumbers();      // グリッド数値の再計算
        }
        
        void DrawAxis(void){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            ClearAxis();    // 背景色で塗りつぶし
            FG.DrawRect(PLOT_LEFT, PLOT_TOP, PLOT_WIDTH, PLOT_HEIGHT, AxisColor);   // グラフ外枠の描画
            DrawGrid();     // グリッドの描画
            DrawLabels();   // ラベルの描画
        }
        
        void ClearAxis(void){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            FG.DrawRectFill(LEFT, TOP, WIDTH, HEIGHT, BackColor);   // 背景色で塗りつぶす
        }
        
        void DrawLegend(size_t i, const std::string& name, const FGcolors& color){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            FG.PrintText(LEFT + LEGEND_LEFT + i*LEGEND_INTERVAL, TOP + LEGEND_TOP, FGalign::ALIGN_LEFT, name);
            FG.DrawRectFill(
                LEFT + LEGEND_LEFT + i*LEGEND_INTERVAL - LEGEND_LINE_WIDTH - 3, TOP + LEGEND_TOP,
                LEGEND_LINE_WIDTH, LEGEND_LINE_HEIGHT,
                color
            );
        }
        
        template <size_t N>
        void DrawLegends(const std::array<std::string, N>& names, const std::array<FGcolors, N>& colors){
            for(size_t i = 0; i < N; ++i){
                DrawLegend(i + 1, names[i], colors[i]);
            }
        }
        
        template <size_t N>
        void DrawLegends(const std::array<std::string, N>& names, const std::array<FGcolors, N>& colors, size_t num){
            for(size_t i = 0; i < num; ++i){
                DrawLegend(i + 1, names[i], colors[i]);
            }
        }
        
        void DrawCursorX(const double x){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            FG.DrawLine(XtoPixel(x), YtoPixel(Ymax) + 1, XtoPixel(x), YtoPixel(Ymin) - 1, CursorColor);
        }
        
        void DrawText(const double x, const double y, const std::string& text){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            FG.PrintText(XtoPixel(x), YtoPixel(y), FGalign::ALIGN_LEFT, text);
        }
        
        void DrawValue(const double x, const double y, const std::string& format, const double val){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            FG.PrintValue(XtoPixel(x), YtoPixel(y), FGalign::ALIGN_LEFT, format, val);
        }
        
        void Plot(const double x, const double y, const CuiPlotTypes type, const uint32_t color){
            PlotSingleData(x, y, x, y, type, color);
        }
        
        void Plot(const double x, const double y, const CuiPlotTypes type, const double r, const double g, const double b){
            Plot(x, y, type, FG.RGBcolorToData(r,g,b));
        }
        
        void Plot(const double x, const double y, const CuiPlotTypes type, const FGcolors color){
            Plot(x, y, type, FG.ColorNameToData(color));
        }
        
        void Plot(const double x1, const double y1, const double x2, const double y2, const CuiPlotTypes type, const uint32_t color){
            PlotSingleData(x1, y1, x2, y2, type, color);
        }
        
        void Plot(const double x1, const double y1, const double x2, const double y2, const CuiPlotTypes type, const double r, const double g, const double b){
            Plot(x1, y1, x2, y2, type, FG.RGBcolorToData(r,g,b));
        }
        
        void Plot(const double x1, const double y1, const double x2, const double y2, const CuiPlotTypes type, const FGcolors color){
            Plot(x1, y1, x2, y2, type, FG.ColorNameToData(color));
        }
        
        template <size_t N>
        void Plot(const std::array<double, N>& x, const std::array<double, N>& y, const CuiPlotTypes type, const uint32_t color){
            for(size_t i = 1; i < N; ++i){
                PlotSingleData(x[i-1], y[i-1], x[i], y[i], type, color);    // 2点間の描画を配列の長さ分だけ実行
            }
        }
        
        template <size_t N>
        void Plot(const std::array<double, N>& x, const std::array<double, N>& y, const CuiPlotTypes type, const double r, const double g, const double b){
            Plot(x, y, type, FG.RGBcolorToData(r,g,b));
        }
        
        template <size_t N>
        void Plot(const std::array<double, N>& x, const std::array<double, N>& y, const CuiPlotTypes type, const FGcolors color){
            Plot(x, y, type, FG.ColorNameToData(color));
        }
        
        template <size_t N>
        void Plot(const Matrix<1,N>& x, const Matrix<1,N>& y, const CuiPlotTypes type, const uint32_t color){
            for(size_t i = 2; i <= N; ++i){
                PlotSingleData(x[i-1], y[i-1], x[i], y[i], type, color);    // 2点間の描画を配列の長さ分だけ実行
            }
        }
        
        template <size_t N>
        void Plot(const Matrix<1,N>& x, const Matrix<1,N>& y, const CuiPlotTypes type, const double r, const double g, const double b){
            Plot(x, y, type, FG.RGBcolorToData(r,g,b));
        }
        
        template <size_t N>
        void Plot(const Matrix<1,N>& x, const Matrix<1,N>& y, const CuiPlotTypes type, const FGcolors color){
            Plot(x, y, type, FG.ColorNameToData(color));
        }
        
        template <unsigned long N, bool M = false>
        void TimeSeriesPlot(RingBuffer<double, N, M>& t, RingBuffer<double, N, M>& y, const CuiPlotTypes type, const uint32_t color){
            const double Tnow = t.GetFirstValue();  // 現在の時刻
            double t1, t2, y1, y2;                  // 加工後の座標
            bool LeapZero = false;                  // 時刻ゼロを跨いだか否か
            
            // リングバッファの分だけ回す
            for(size_t i = 1; i < N; ++i){
                // リングバッファの最先端(現在)から後方(過去)に向けて座標を抽出
                t2 = t.GetRelativeValueFromFirst(i - 1);
                y2 = y.GetRelativeValueFromFirst(i - 1);
                t1 = t.GetRelativeValueFromFirst(i);
                y1 = y.GetRelativeValueFromFirst(i);
                
                if(LeapZero == true && t1 <= Tnow) break;   // 時刻ゼロを跨ぎ，尚且つ現在時刻より前になったら描画終了
                if(LeapZero == true && t2 < t1) break;      // 時刻ゼロを2回跨いでも描画終了 (Tnow≒0で if(t1 <= Tnow) をすり抜けるときの対策)
                
                if(t1 <= t2){
                    // 普通のときは普通に描画
                    PlotSingleData(t1, y1, t2, y2, type, color);
                }else{
                    // 時刻ゼロを跨いだとき
                    LeapZero = true;
                }
            }
            
            DrawCursorX(Tnow);  // 時刻カーソルを現在時刻のところに表示
        }
        
        template <unsigned long N, bool M = false>
        void TimeSeriesPlot(RingBuffer<double, N, M>& t, RingBuffer<double, N, M>& y, const CuiPlotTypes type, const double r, const double g, const double b){
            TimeSeriesPlot(t, y, type, FG.RGBcolorToData(r, g, b));
        }
        
        template <unsigned long N, bool M = false>
        void TimeSeriesPlot(RingBuffer<double, N, M>& t, RingBuffer<double, N, M>& y, const CuiPlotTypes type, const FGcolors color){
            TimeSeriesPlot(t, y, type, FG.ColorNameToData(color));
        }
        
        void Disp(void){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            FG.RefreshFrame(LEFT, TOP, WIDTH, HEIGHT);  // フレームバッファ更新
        }
        
        void StorePlaneInBuffer(void){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            FG.StoreScreenAsBackground(LEFT, TOP, WIDTH, HEIGHT);
        }
        
        void LoadPlaneFromBuffer(void){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            FG.LoadBackgroundToScreen(LEFT, TOP, WIDTH, HEIGHT);
        }
        
        void Visible(bool visible){
            VisibleFlag = visible;
        }
        
    private:
        CuiPlot(const CuiPlot&) = delete;                       
        const CuiPlot& operator=(const CuiPlot&) = delete;      
        static constexpr int MARGIN_TOP = 14;                   
        static constexpr int MARGIN_BOTTOM = 23;                
        static constexpr int MARGIN_WIDTH = 30;                 
        static constexpr int MARGIN_WIDTH_X2 = MARGIN_WIDTH*2;  
        static constexpr int GRID_AXISLEN = 5;                  
        static constexpr int LABEL_VERTICAL_ALIGN = 4;          
        static constexpr int LABEL_MARGIN_X = 3;                
        static constexpr int LABEL_MARGIN_Y = 5;                
        static constexpr int LEGEND_LEFT = 100;                 
        static constexpr int LEGEND_TOP  = 3;                   
        static constexpr int LEGEND_INTERVAL = 70;              
        static constexpr int LEGEND_LINE_WIDTH  = 9;            
        static constexpr int LEGEND_LINE_HEIGHT = 9;            
        static constexpr size_t XGRID_MAX = 16;                 
        static constexpr size_t YGRID_MAX = 16;                 
        const int LEFT;         
        const int TOP;          
        const int WIDTH;        
        const int HEIGHT;       
        const int PLOT_LEFT;    
        const int PLOT_TOP;     
        const int PLOT_WIDTH;   
        const int PLOT_HEIGHT;  
        
        FrameGraphics& FG;      
        FGcolors AxisColor;     
        FGcolors GridColor;     
        FGcolors TextColor;     
        FGcolors BackColor;     
        FGcolors CursorColor;   
        double Xmax;            
        double Xmin;            
        double Ymax;            
        double Ymin;            
        double Xwidth;          
        double Yheight;         
        std::array<double, XGRID_MAX> Xgrid;    
        std::array<double, YGRID_MAX> Ygrid;    
        size_t XgridNum;        
        size_t YgridNum;        
        std::string Xform;      
        std::string Yform;      
        std::string Xlabel;     
        std::string Ylabel;     
        bool VisibleFlag;       
        
        void CalcGridNumbers(void){
            // X軸グリッド数値の計算
            for(size_t i = 0; i < XgridNum; ++i){
                Xgrid[i] = (Xmax - Xmin)/(double)XgridNum*(double)(i + 1) + Xmin;
            }
            // Y軸グリッド数値の計算
            for(size_t i = 0; i < YgridNum; ++i){
                Ygrid[i] = (Ymax - Ymin)/(double)YgridNum*(double)(i + 1) + Ymin;
            }
        }
        
        int XtoPixel(double x) const{
            if(Xmax < x) x = Xmax;
            if(x < Xmin) x = Xmin;
            return (int)((double)PLOT_WIDTH/Xwidth*(x - Xmin)) + PLOT_LEFT;
        }
        
        int YtoPixel(double y) const{
            if(Ymax < y) y = Ymax;
            if(y < Ymin) y = Ymin;
            return (int)((double)PLOT_HEIGHT/Yheight*(-y + Ymax)) + PLOT_TOP;
        }
        
        void DrawGrid(void){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            // X軸グリッドの描画
            for(size_t i = 0; i < XgridNum - 1; ++i){
                FG.DrawLine(XtoPixel(Xgrid[i]), YtoPixel(Ymin), XtoPixel(Xgrid[i]), YtoPixel(Ymax), GridColor);                 // グリッド線の描画
                FG.DrawLine(XtoPixel(Xgrid[i]), YtoPixel(Ymin), XtoPixel(Xgrid[i]), YtoPixel(Ymin) - GRID_AXISLEN, AxisColor);  // 下側目盛線の描画
                FG.DrawLine(XtoPixel(Xgrid[i]), YtoPixel(Ymax), XtoPixel(Xgrid[i]), YtoPixel(Ymax) + GRID_AXISLEN, AxisColor);  // 上側目盛線の描画
            }
            // Y軸グリッドの描画
            for(size_t i = 0; i < YgridNum - 1; ++i){
                FG.DrawLine(XtoPixel(Xmin), YtoPixel(Ygrid[i]), XtoPixel(Xmax), YtoPixel(Ygrid[i]), GridColor);                 // グリッド線の描画
                FG.DrawLine(XtoPixel(Xmin), YtoPixel(Ygrid[i]), XtoPixel(Xmin) + GRID_AXISLEN, YtoPixel(Ygrid[i]), AxisColor);  // 左側目盛線の描画
                FG.DrawLine(XtoPixel(Xmax), YtoPixel(Ygrid[i]), XtoPixel(Xmax) - GRID_AXISLEN, YtoPixel(Ygrid[i]), AxisColor);  // 右側目盛線の描画
            }
        }
        
        void DrawLabels(void){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            // グリッドラベルの描画
            for(size_t i = 0; i < XgridNum - 1; ++i){
                FG.PrintValue(XtoPixel(Xgrid[i]), YtoPixel(Ymin) + LABEL_MARGIN_X, FGalign::ALIGN_CENTER, Xform, Xgrid[i]); // X軸グリッドラベル
            }
            for(size_t i = 0; i < YgridNum - 1; ++i){
                FG.PrintValue(XtoPixel(Xmin) - LABEL_MARGIN_Y, YtoPixel(Ygrid[i]) - LABEL_VERTICAL_ALIGN, FGalign::ALIGN_RIGHT, Yform, Ygrid[i]);   // Y軸グリッドラベル
            }
            // X軸 最小値と最大値ラベルの描画
            FG.PrintValue(XtoPixel(Xmax), YtoPixel(Ymin) + LABEL_MARGIN_X, FGalign::ALIGN_CENTER, Xform, Xmax); // 最大値ラベル
            FG.PrintValue(XtoPixel(Xmin), YtoPixel(Ymin) + LABEL_MARGIN_X, FGalign::ALIGN_CENTER, Xform, Xmin); // 最小値ラベル
            // Y軸 最小値と最大値ラベルの描画
            FG.PrintValue(XtoPixel(Xmin) - LABEL_MARGIN_Y, YtoPixel(Ymax), FGalign::ALIGN_RIGHT, Yform, Ymax);  // 最大値ラベル   
            FG.PrintValue(XtoPixel(Xmin) - LABEL_MARGIN_Y, YtoPixel(Ymin) - LABEL_VERTICAL_ALIGN*2, FGalign::ALIGN_RIGHT, Yform, Ymin); // 最小値ラベル
            // XY軸ラベルの描画
            FG.PrintText(XtoPixel(Xwidth/2.0 + Xmin), YtoPixel(Ymin) + LABEL_VERTICAL_ALIGN*2 + LABEL_MARGIN_X*2, FGalign::ALIGN_CENTER, Xlabel);   // X軸ラベル
            FG.PrintText(LEFT + 2, TOP + 2, FGalign::ALIGN_LEFT, Ylabel);   // Y軸ラベル
        }
        
        void PlotSingleData(const double x1, const double y1, const double x2, const double y2, const CuiPlotTypes type, const uint32_t color){
            if(VisibleFlag == false) return;            // 不可視設定なら何もせず終了
            switch(type){
                case CuiPlotTypes::PLOT_LINE:       // 線プロットのとき
                    FG.DrawLine(XtoPixel(x1), YtoPixel(y1), XtoPixel(x2), YtoPixel(y2), color);
                    break;
                case CuiPlotTypes::PLOT_BOLDLINE:   // 太線プロットのとき
                    FG.DrawLine<FGsize::PX_2>(XtoPixel(x1), YtoPixel(y1), XtoPixel(x2), YtoPixel(y2), color);
                    break;
                case CuiPlotTypes::PLOT_DOT:        // 点プロットのとき
                    FG.DrawPoint(XtoPixel(x1), YtoPixel(y1), color);
                    break;
                case CuiPlotTypes::PLOT_BOLDDOT:    // 太い点プロットのとき
                    FG.DrawPoint<FGsize::PX_3>(XtoPixel(x1), YtoPixel(y1), color);
                    break;
                case CuiPlotTypes::PLOT_CROSS:      // 十字プロットのとき
                    FG.DrawCross(XtoPixel(x1), YtoPixel(y1), color);
                    break;
                case CuiPlotTypes::PLOT_STAIRS:     // 階段プロットのとき
                    FG.DrawStairs(XtoPixel(x1), YtoPixel(y1), XtoPixel(x2), YtoPixel(y2), color);
                    break;
                case CuiPlotTypes::PLOT_BOLDSTAIRS: // 太線階段プロットのとき
                    FG.DrawStairs<FGsize::PX_2>(XtoPixel(x1), YtoPixel(y1), XtoPixel(x2), YtoPixel(y2), color);
                    break;
                case CuiPlotTypes::PLOT_LINEANDDOT: // 線と点の複合プロットのとき
                    FG.DrawLine(XtoPixel(x1), YtoPixel(y1), XtoPixel(x2), YtoPixel(y2), color);
                    FG.DrawPoint<FGsize::PX_3>(XtoPixel(x1), YtoPixel(y1), color);
                    break;
                default:
                    arcs_assert(false); // ここには来ない
                    break;
            }
        }
};
}
 
#endif