plot2d.h

#include <nana/gui.hpp>
#include <nana/gui/widgets/label.hpp>
#include <nana/gui.hpp>

namespace nana
{
namespace plot
{
class plot;

class trace
{
public:

    trace()
        : myType( eType::plot )
    {

    }
    void realTime( int w )
    {
        myType = eType::realtime;
        myRealTimeNext = 0;
        myY.clear();
        myY.resize( w );
    }

    void points()
    {
        myType = eType::point;
        myY.clear();
        myX.clear();
    }

    void set( const std::vector< double >& y );

    void add( double y );

    void add( double x, double y );

    void color( const colors & clr )
    {
        myColor = clr;
    }

    void Plot( plot * p )
    {
        myPlot = p;
    }

    int size()
    {
        return (int) myY.size();
    }

    void bounds( int& min, int& max );

    void update( paint::graphics& graph );

private:
    plot * myPlot;
    std::vector< double > myX;
    std::vector< double > myY;
    colors myColor;
    int myRealTimeNext;
    enum class eType
    {
        plot,
        realtime,
        point
    } myType;
};
class axis
{
public:
    axis( plot * p );

    ~axis()
    {
        delete myLabelMin;
        delete myLabelMax;
    }

    void update( paint::graphics& graph );

private:
    plot * myPlot;
    label * myLabelMin;
    label * myLabelMax;
};


class plot
{
public:

    plot( window parent );

    ~plot()
    {
        delete myAxis;
    }

    trace& AddStaticTrace()
    {
        trace * t = new trace();
        t->Plot( this );
        myTrace.push_back( t );
        return *t;
    }

    trace& AddRealTimeTrace( int w )
    {
        trace * t = new trace();
        t->Plot( this );
        t->realTime( w );
        myTrace.push_back( t );
        return *t;
    }

    trace& AddPointTrace();

    int Y2Pixel( double y ) const
    {
        return myYOffset - myScale * y;
    }

    float xinc()
    {
        return myXinc;
    }
    int minY()
    {
        return myMinY;
    }
    int maxY()
    {
        return myMaxY;
    }
    double Scale()
    {
        return myScale;
    }
    int XOffset()
    {
        return myXOffset;
    }
    int YOffset()
    {
        return myYOffset;
    }
    window parent()
    {
        return myParent;
    }

    void update()
    {
        API::refresh_window( myParent );
    }

    void debug()
    {
        for( auto t : myTrace )
        {
            std::cout << "debugtsize " << t->size() << "\n";
        }
    }

private:

    window myParent;

    axis * myAxis;

    std::vector< trace* > myTrace;

    float myXinc;
    int myMinY, myMaxY;
    double myScale;
    int myXOffset;
    int myYOffset;

    void CalcScale( int w, int h );

    void RegisterDrawingFunction();

};

}
}