plot2d.h

#pragma once
 
#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <limits>
#include <cfloat>
 
#include <wex.h>
 
// minimum data range that will produce sensible plots
#define minDataRange 0.000001
 
namespace wex
{
    namespace plot
    {
        class plot;
 
 
        class cCircularBuffer
        {
            int myCurrentID;     // buffer index for current iteration
            int myLastValid;     // index of most recent data point
            int mySize;          // largest buffer index
            bool myfWrapped;     // true if buffer is full aand wrap around has occurred
            bool myfCurrentLast; // true if current iteration is at most recent data point
            bool myfIterating;   // an iteration is in progress
 
        public:
            cCircularBuffer()
                : myCurrentID(-1), myLastValid(-1), mySize(-1),
                  myfWrapped(false), myfCurrentLast(false), myfIterating(false)
            {
            }
 
            void set(int s)
            {
                mySize = s;
            }
 
            bool isValidData() const
            {
                return myLastValid >= 0;
            }
 
            bool isFull()
            {
                return myfWrapped;
            }
 
            int add()
            {
                if (mySize < 0)
                    throw std::logic_error(
                        "cCircularBuffer::add() called without size buffer");
 
                if (myfIterating)
                    throw std::logic_error(
                        "cCircularBuffer::add() called during iteration");
 
                myLastValid++;
                if (myLastValid > mySize)
                {
                    myLastValid = 0;
                    myfWrapped = true;
                }
                return myLastValid;
            }
 
            int first()
            {
                if (myLastValid < 0)
                    return -1;
                myfIterating = true;
                if (!myfWrapped)
                {
                    myCurrentID = 0;
                    myfCurrentLast = false;
                    if (myLastValid == 0)
                        myfCurrentLast = true;
                }
                else
                {
                    myCurrentID = myLastValid + 1;
                    if (myCurrentID > mySize)
                        myCurrentID = 0;
                    myfCurrentLast = false;
                }
                return myCurrentID;
            }
 
            int next()
            {
                // check for no data in buffer
                if (myLastValid < 0)
                    return -1;
 
                // check for end of data
                if (myfCurrentLast)
                {
                    myfIterating = false;
                    return -1;
                }
 
                myCurrentID++;
 
                if (myCurrentID > mySize)
                    myCurrentID = 0;
 
                if (myCurrentID == myLastValid)
                    myfCurrentLast = true;
 
                return myCurrentID;
            }
        };
 
        class scaleStateMachine
        {
        public:
            enum class eState
            {
                none,
                fit,
                fix,
                fitzoom,
                fixzoom,
            };
            enum class eEvent
            {
                start,
                zoom,
                unzoom,
                fix,
                fit,
            };
 
            eState myState;
 
            scaleStateMachine()
                : myState(eState::fit)
            {
            }
 
            eState event(eEvent event)
            {
                switch (event)
                {
 
                case eEvent::start:
                    // handled by constructor
                    return eState::fit;
 
                case eEvent::zoom:
                    switch (myState)
                    {
                    case eState::fit:
                        myState = eState::fitzoom;
                        break;
                    case eState::fix:
                        myState = eState::fixzoom;
                        break;
                    default:
                        return eState::none;
                    }
                    break;
 
                case eEvent::unzoom:
                    switch (myState)
                    {
                    case eState::fitzoom:
                        myState = eState::fit;
                        break;
                    case eState::fixzoom:
                        myState = eState::fix;
                        break;
                    default:
                        return eState::none;
                    }
                    break;
 
                case eEvent::fix:
                    switch (myState)
                    {
                    case eState::fit:
                        myState = eState::fix;
                        break;
                    default:
                        return eState::none;
                    }
                    break;
 
                case eEvent::fit:
                    switch (myState)
                    {
                    case eState::fit:
                        break;
                    case eState::fix:
                        myState = eState::fit;
                        break;
                    default:
                        return eState::none;
                    }
                    break;
 
                default:
                    throw std::runtime_error(
                        "plot scaleStateMachine unrecognized event");
                }
 
                // std::cout << "scaleStateMachine state change " << (int)myState << "\n";
 
                return myState;
            }
        };
 
        class XScale
        {
            scaleStateMachine::eState &theState;
 
            int xpmin; // min pixel
            int xpmax; // max pixel
 
            int ximin; // min data index
            int ximax; // max data index
 
            double xumin;   // min displayed x user value
            double xuximin; // user x value for ximin
            double xumax;   // max user x value displayed
            double xixumin; // data index for user x min
 
            double xuminfix;
            double xumaxfix;
            double xuminZoom;
            double xumaxZoom;
 
            double sxi2xu; // scale from data index to x user
            double sxi2xp; // scale from data index to pixel
            double sxu2xp; // scale from x user to pixel
 
        public:
            XScale(scaleStateMachine &machine)
                : theState(machine.myState)
            {
            }
            void xiSet(int min, int max)
            {
                ximin = min;
                ximax = max;
            }
            void xpSet(int min, int max)
            {
                xpmin = min;
                xpmax = max;
            }
 
 
            void xi2xuSet(double u0, double sc)
            {
                xuximin = u0;
                sxi2xu = sc;
            }
            void fixSet(double min, double max)
            {
                xuminfix = min;
                xumaxfix = max;
            }
 
 
            void zoom(double umin, double umax)
            {
                xuminZoom = umin;
                xumaxZoom = umax;
            }
            void zoomExit()
            {
            }
 
            void calculate()
            {
                switch (theState)
                {
                case scaleStateMachine::eState::fit:
                    xumin = xuximin;
                    xumax = xumin + sxi2xu * ximax;
                    xixumin = 0;
                    sxi2xp = (double)(xpmax - xpmin) / (ximax - ximin);
                    sxu2xp = (xpmax - xpmin) / (xumax - xumin);
                    break;
 
                case scaleStateMachine::eState::fix:
                {
                    xumin = xuminfix;
                    xumax = xumaxfix;
                    xixumin = (xumin - xuximin) / sxi2xu;
                    double xixumax = (xumax - xuximin) / sxi2xu;
                    sxi2xp = (xpmax - xpmin) / (xixumax - xixumin);
                    sxu2xp = (xpmax - xpmin) / (xumax - xumin);
                }
                break;
 
                case scaleStateMachine::eState::fitzoom:
                case scaleStateMachine::eState::fixzoom:
                {
                    xumin = xuminZoom;
                    xumax = xumaxZoom;
                    xixumin = (xumin - xuximin) / sxi2xu;
                    double xixumax = (xumax - xuximin) / sxi2xu;
                    sxi2xp = (xpmax - xpmin) / (xixumax - xixumin);
                    sxu2xp = (xpmax - xpmin) / (xumax - xumin);
                }
                break;
                }
            }
 
            int XI2XP(double xi) const
            {
                // std::cout << "XI2XP " << xi
                //     << " xpmin " << xpmin
                //     << " sxi2xp " << sxi2xp
                //     << " xixumin " << xixumin
                //     << "\n";
 
                return round(xpmin + sxi2xp * (xi - xixumin));
            }
            double XP2XU(int pixel) const
            {
                return xumin + (pixel - xpmin) / sxu2xp;
            }
            int XU2XP(double xu) const
            {
                return round(xpmin + sxu2xp * (xu - xumin));
            }
 
            double XUmin() const
            {
                return xumin;
            }
            double XUmax() const
            {
                return xumax;
            }
            int XPmin() const
            {
                return xpmin;
            }
            int XPmax() const
            {
                return xpmax;
            }
 
            void text() const
            {
                std::cout
                    << "state " << (int)theState
                    << " xpstart " << xpmin << " xpmax " << xpmax
                    << " xistart " << ximin << " ximax " << ximax
                    << " xustart " << xumin << " xumax " << xumax
                    << " sxi2xp " << sxi2xp
                    << " sxi2xu " << sxi2xu
                    << "\n";
            }
        };
 
        class YScale
        {
            scaleStateMachine::eState &theState;
            double yvmin;     // smallest value in data currently displayed
            double yvmax;     // largest value in data currently displayed
            int ypmin;        // y pixel showing smallest data value
            int ypmax;        // y pixel showing largest data value
            double syv2yp;    // scale from data value to y pixel
            double yvminZoom; // smallest value in data when zoomed
            double yvmaxZoom; // largest value in data when zoomed
            double yvminFit;  // smallest value in data when fitted
            double yvmaxFit;  // largest value in data when fitted
            double yvminFix;  // smallest value in data when fixed
            double yvmaxFix;  // largest value in data when fixed
 
        public:
            YScale(scaleStateMachine &scaleMachine)
                : theState(scaleMachine.myState)
            {
            }
 
            void YVrange(double min, double max)
            {
                switch (theState)
                {
                case scaleStateMachine::eState::fit:
                    yvminFit = min;
                    yvmaxFit = max;
                    break;
                case scaleStateMachine::eState::fix:
                    yvminFix = min;
                    yvminFix = max;
                    break;
                }
            }
 
            double YVrange() const
            {
                return yvmax - yvmin;
            }
 
 
            void YPrange(int min, int max)
            {
                ypmin = min;
                ypmax = max;
                calculate();
            }
 
            void zoom(double min, double max)
            {
                yvminZoom = min;
                yvmaxZoom = max;
            }
 
            void fixSet(double min, double max)
            {
                yvminFix = min;
                yvmaxFix = max;
            }
 
            double YP2YV(int pixel) const
            {
                return yvmin - (ypmin - pixel) / syv2yp;
            }
 
            int YV2YP(double v) const
            {
                return ypmin + syv2yp * (v - yvmin);
            }
            double YVmin() const
            {
                return yvmin;
            }
            double YVmax() const
            {
                return yvmax;
            }
            int YPmin() const
            {
                return ypmin;
            }
            int YPmax() const
            {
                return ypmax;
            }
            void text() const
            {
                std::cout << "yv " << yvmin << " " << yvmax
                          << " xp " << ypmin << " " << ypmax
                          << " " << syv2yp
                          << "\n";
            }
 
            void calculate()
            {
                switch (theState)
                {
                case scaleStateMachine::eState::fit:
                    yvmin = yvminFit;
                    yvmax = yvmaxFit;
                    break;
 
                case scaleStateMachine::eState::fix:
                    yvmin = yvminFix;
                    yvmax = yvmaxFix;
                    break;
 
                case scaleStateMachine::eState::fitzoom:
                case scaleStateMachine::eState::fixzoom:
                    yvmin = yvminZoom;
                    yvmax = yvmaxZoom;
                    break;
                }
                double yvrange = yvmax - yvmin;
                if (fabs(yvrange) < 0.00001)
                {
                    // seems like there are no meaningful data
                    syv2yp = 1;
                    return;
                }
 
                syv2yp = -(ypmin - ypmax) / yvrange;
            }
 
 
            std::vector<double> tickValues() const
            {
                std::vector<double> vl;
                double rangeV = fabs(yvmax - yvmin);
                if (rangeV < minDataRange)
                {
                    // plot is single valued
                    // display just one tick
                    vl.push_back(yvmin);
                    return vl;
                }
                double incV = rangeV / 4;
                double tickValue;
                if (incV > 1)
                    incV = (int)incV;
 
                tickValue = yvmin;
 
                while (true)
                {
                    double v = tickValue;
                    if (v > 100)
                        v = ((int)v / 100) * 100;
                    else if (v > 10)
                        v = ((int)v / 10) * 10;
                    vl.push_back(v);
                    tickValue += incV;
                    if (tickValue >= yvmax)
                        break;
                }
                // vl.push_back(mx);
                return vl;
            }
        };
 
        // @endcond
 
        class trace
        {
        public:
            enum class eType
            {
                plot,
                realtime,
                scatter
            } myType; // trace type
 
            void set(const std::vector<double> &y)
            {
                if ((myType != eType::plot) && (myType != eType::scatter))
                    throw std::runtime_error("plot2d error: plot data added to non plot/scatter trace");
 
                myY = y;
            }
            void set(double *begin, double *end)
            {
                if ((myType != eType::plot) && (myType != eType::scatter))
                    throw std::runtime_error("plot2d error: plot data added to non plot/scatter trace");
 
                myY = std::vector(begin, end);
            }
            void setScatterX(const std::vector<double> &x)
            {
                if (myType != eType::scatter)
                    throw std::runtime_error("plot2d error: plot X added to non scatter trace");
 
                myX = x;
            }
            std::vector<double> get() const
            {
                return myY;
            }
 
            void add(double y)
            {
                if (myType != eType::realtime)
                    throw std::runtime_error("plot2d error: realtime data added to non realtime trace");
                myY[myCircular.add()] = y;
            }
 
            void add(double x, double y)
            {
                if (myType != eType::scatter)
                    throw std::runtime_error("plot2d error: point data added to non scatter type trace");
                myX.push_back(x);
                myY.push_back(y);
            }
 
            void clear()
            {
                myX.clear();
                myY.clear();
            }
 
            void color(int clr)
            {
                myColor = clr;
            }
            int color() const
            {
                return myColor;
            }
 
            void thick(int t)
            {
                myThick = t;
            }
            int thick() const
            {
                return myThick;
            }
 
            int size() const
            {
                return (int)myY.size();
            }
 
            double value(double xfraction)
            {
                if (0 > xfraction || xfraction > 1)
                    return 0;
                return myY[(int)(xfraction * myY.size())];
            }
 
            const std::vector<double> &getX() const
            {
                return myX;
            }
            const std::vector<double> &getY()
            {
                if (myType != eType::realtime)
                    return myY;
 
                static std::vector<double> ret;
                ret.clear();
                for (int yidx = myCircular.first();
                     yidx >= 0;
                     yidx = myCircular.next())
                    ret.push_back(myY[yidx]);
                return ret;
            }
 
        private:
            friend plot;
 
            plot *myPlot;               // plot where this trace is displayed
            std::vector<double> myX;    // X value of each data point
            std::vector<double> myY;    // Y value of each data point
            cCircularBuffer myCircular; // maintain indices of circular buffer used by real time trace
            int myColor;                // trace color
            int myThick;                // trace thickness
 
            trace()
                : myThick(1), myType(eType::plot)
            {
            }
 
            void Plot(plot *p)
            {
                myPlot = p;
            }
 
            void realTime(int w)
            {
                myType = eType::realtime;
                myY.clear();
                myY.resize(w);
                myCircular.set(w);
            }
 
            void scatter()
            {
                myType = eType::scatter;
                myY.clear();
                myX.clear();
            }
 
            void bounds(
                int &txmin, int &txmax,
                double &tymin, double &tymax)
            {
                if (myY.size())
                {
 
                    // find the x limits
 
                    txmin = 0;
                    txmax = myY.size() - 1;
 
                    // if (myType == eType::realtime || myX.size() == 0)
                    //  {
                    //      txmin = 0;
                    //      txmax = myY.size();
                    //  }
                    //  else
                    //  {
                    //      // auto result = std::minmax_element(
                    //      //     myX.begin(),
                    //      //     myX.end());
                    //      // txmin = *result.first;
                    //      // txmax = *result.second;
                    //      txmin =
                    //  }
 
                    // find the y limits
 
                    if (myType == eType::realtime)
                    {
                        if (!myCircular.isValidData())
                        {
                            // no data is buffer
                            tymin = -5;
                            tymax = 5;
                            return;
                        }
 
                        if (myCircular.isFull())
                        {
                            // buffer is full
                            auto result = std::minmax_element(
                                myY.begin(),
                                myY.end());
                            tymin = *result.first;
                            tymax = *result.second;
                        }
 
                        // buffer is partially full
                        // set bounds using the data that has been received so far
                        tymin = myY[0];
                        tymax = myY[0];
                        for (int idx = myCircular.first();
                             idx >= 0;
                             idx = myCircular.next())
                        {
                            double y = myY[idx];
                            if (y < tymin)
                                tymin = y;
                            if (y > tymax)
                                tymax = y;
                        }
                    }
                    else
                    {
                        // scatter or static trace
                        auto result = std::minmax_element(
                            myY.begin(),
                            myY.end());
                        tymin = *result.first;
                        tymax = *result.second;
                    }
                }
            }
        };
 
        class axis
        {
        public:
            enum class eOrient
            {
                none,
                horz,
                vert,
            };
 
            axis()
                : myfEnable(true),
                  myfGrid(false)
            {
            }
 
            void set(
                eOrient o)
            {
                myOrient = o;
            }
 
            void enable(bool f = true)
            {
                myfEnable = f;
            }
 
            void setValueRange(
                double min,
                double max)
            {
                myvmin = min;
                myvmax = max;
            }
 
            void setGrid(bool f = true)
            {
                myfGrid = f;
            }
 
            void draw(
                wex::shapes &S,
                const XScale &xs,
                const YScale &ys)
            {
                if (!myfEnable)
                    return;
 
                double scale;
                int tickCount = 8;
                int paxis;
                int tickPixel;
                if (myOrient == eOrient::horz)
                {
                    paxis = ys.YPmin();
                    S.line({xs.XPmin(), paxis,
                            xs.XPmax(), paxis});
                    scale = (xs.XPmax() - xs.XPmin()) / (xs.XUmax() - xs.XUmin());
                }
                else
                {
                    // // y pixels are indexed from top of screen
                    paxis = xs.XPmin();
                    tickCount = 4;
 
                    S.line({paxis, ys.YPmin(),
                            paxis, ys.YPmax()});
 
                    scale = (ys.YPmax() - ys.YPmin()) / ys.YVrange();
                }
 
                for (double tickValue : tickValues(tickCount, myvmin, myvmax))
                {
                    switch (myOrient)
                    {
                    case eOrient::horz:
 
                        tickPixel = xs.XPmin() + scale * (tickValue - xs.XUmin());
                        S.line(
                            {tickPixel, paxis - 5,
                             tickPixel, paxis + 5});
                        S.text(
                            numberformat(tickValue),
                            {tickPixel, paxis + 5,
                             tickPixel + 50, paxis + 15});
                        if (myfGrid)
                        {
                            for (int kp = paxis;
                                 kp >= ys.YPmax();
                                 kp -= 25)
                            {
                                S.pixel(tickPixel, kp);
                                S.pixel(tickPixel, kp + 1);
                            }
                        }
                        break;
 
                    case eOrient::vert:
 
                        tickPixel = ys.YPmin() + scale * (tickValue - ys.YVmin());
                        S.line({paxis - 5, tickPixel,
                                paxis + 5, tickPixel});
                        S.text(
                            numberformat(tickValue),
                            {paxis - 50, tickPixel, paxis - 5, tickPixel + 15});
                        if (myfGrid)
                        {
                            for (int kp = paxis;
                                 kp < xs.XPmax();
                                 kp += 25)
                            {
                                S.pixel(kp, tickPixel);
                                S.pixel(kp + 1, tickPixel);
                            }
                        }
                        break;
                    }
                }
            }
 
        private:
            eOrient myOrient;
            double myvmin;
            double myvmax;
            bool myfEnable;
            bool myfGrid;
 
            std::vector<double> tickValues(
                int count,
                double min,
                double max)
            {
                std::vector<double> ret;
                double tickinc = (max - min) / count;
                if (tickinc > 1)
                    tickinc = floor(tickinc);
                for (
                    double v = min;
                    v < max;
                    v += tickinc)
                {
                    ret.push_back(v);
                }
                return ret;
            }
 
            std::string numberformat(double f)
            {
                if (f == 0)
                {
                    return "0";
                }
                int n = 3;                                         // number of significant digits
                int d = (int)::floor(::log10(f < 0 ? -f : f)) + 1; /*digits before decimal point*/
                double order = ::pow(10., n - d);
                std::stringstream ss;
                ss << std::fixed << std::setprecision(std::max(n - d, 0)) << round(f * order) / order;
                return ss.str();
            }
        };
 
        // class rightAxis : public axis
        // {
        //     bool myfEnable;
 
        // public:
        //     rightAxis()
        //         : myfEnable(false)
        //     {
        //     }
        //     void enable()
        //     {
        //         myfEnable = true;
        //         set( eOrient::vert );
        //     }
        // };
 
        class plot : public gui
        {
        public:
            plot(gui *parent)
                : gui(parent), myfDrag(false),
                  myXScale(myScaleStateMachine),
                  myYScale(myScaleStateMachine),
                  mypBottomMarginWidth(50),
                  mypLeftMarginWidth(70)
            {
                text("Plot");
                myRightAxis.enable(false);
                myRightAxis.set(axis::eOrient::vert);
                myLeftAxis.set(axis::eOrient::vert);
                myBottomAxis.set(axis::eOrient::horz);
 
                events().draw(
                    [this](PAINTSTRUCT &ps)
                    {
                        // calculate scaling factors
                        // so plot will fit
                        if (!CalcScale(ps.rcPaint.right,
                                       ps.rcPaint.bottom))
                        {
                            wex::msgbox("Plot has no data");
                            return;
                        }
 
                        wex::shapes S(ps);
 
                        // draw axis
                        drawAxis(S);
 
                        // loop over traces
                        for (auto t : myTrace)
                            drawTrace(t, S);
 
                        drawSelectedArea(ps);
                    });
 
                events().click(
                    [&]
                    {
                        // start dragging for selected area
                        auto m = getMouseStatus();
                        myStartDragX = m.x;
                        myStartDragY = m.y;
                        myStopDragX = -1;
                        myfDrag = true;
                    });
                events().mouseMove(
                    [&](wex::sMouse &m)
                    {
                        // extend selected area as mouse is dragged
                        dragExtend(m);
                    });
                events().mouseUp(
                    [&]
                    {
                        zoomHandler();
                        myfDrag = false;
                        update();
                    });
 
                events().clickRight(
                    [&]
                    {
                        myScaleStateMachine.event(scaleStateMachine::eEvent::unzoom);
                        update();
                    });
            }
 
            ~plot()
            {
            }
 
            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 &AddScatterTrace()
            {
                trace *t = new trace();
                t->Plot(this);
                t->scatter();
                myTrace.push_back(t);
                return *t;
            }
 
            void grid(bool enable)
            {
                myfGrid = enable;
                myLeftAxis.setGrid(enable);
                myBottomAxis.setGrid(enable);
            }
 
 
            void setFixedScale(
                double minX, double maxX, double minY, double maxY)
            {
                if (maxX <= minX || maxY <= minY)
                    throw std::runtime_error(
                        "plot::setFixedScale bad params");
 
                // change scale state
                if (
                    myScaleStateMachine.event(
                        scaleStateMachine::eEvent::fix) == scaleStateMachine::eState::none)
                    return;
 
                if (!myfXset)
                    XUValues(0, 1);
 
                myXScale.fixSet(minX, maxX);
                myYScale.fixSet(minY, maxY);
 
                // myXScale.text();
            }
 
            void setFitScale()
            {
                if (
                    myScaleStateMachine.event(
                        scaleStateMachine::eEvent::fit) == scaleStateMachine::eState::none)
                    throw std::runtime_error(
                        "wex plot cannot return to fit scale");
            }
 
 
            void setMarginWidths(int pBottomMarginWidth, int pLeftMarginWidth)
            {
                mypBottomMarginWidth = pBottomMarginWidth;
                mypLeftMarginWidth = pLeftMarginWidth;
            }
 
            void setXAxisLabel(const std::string &label)
            {
                myXAxisLabel = label;
            }
            void setYAxisLabel(const std::string &label)
            {
                myYAxisLabel = label;
            }
 
 
            void setRightAxis(
                double minValue,
                double maxValue)
            {
                myRightAxis.enable();
                myRightAxis.setValueRange(
                    minValue,
                    maxValue);
            }
 
            int traceCount() const
            {
                return (int)myTrace.size();
            }
 
            void clear()
            {
                myTrace.clear();
            }
 
            // void fixYVminmax(double min, double max)
            // {
            //     myfFit = false;
            //     myfZoom = false;
            //     myYScale.YVrange(min, max);
            // }
 
            // void autoFit()
            // {
            //     myfFit = true;
            //     myfDrag = false;
            //     myfZoom = false;
            //     myXScale.zoomExit();
            //     update();
            // }
 
            void dragExtend(sMouse &m)
            {
                if (!myfDrag)
                    return;
                myStopDragX = m.x;
                myStopDragY = m.y;
                update();
            }
            void XUValues(
                float start_xu,
                float scale_xi2xu)
            {
                myXScale.xi2xuSet(start_xu, scale_xi2xu);
                myfXset = true;
            }
 
            void XValues(
                float start_xu,
                float scale_xi2xu)
            {
                XUValues(start_xu, scale_xi2xu);
            }
 
            std::vector<trace *> &traces()
            {
                return myTrace;
            }
 
            const YScale &yscale() const
            {
                return myYScale;
            }
 
            double pixel2Xuser(int xpixel) const
            {
                return myXScale.XP2XU(xpixel);
            }
 
            int xuser2pixel(double xu) const
            {
                return myXScale.XU2XP(xu);
            }
 
            double pixel2Yuser(int ypixel) const
            {
                return myYScale.YP2YV(ypixel);
            }
 
            int yuser2pixel(double yu) const
            {
                return myYScale.YV2YP(yu);
            }
 
// methods that need to be unit tested, and therefore need to be public
#ifndef UNIT_TEST
        private:
#endif
 
            bool CalcScale(int w, int h)
            {
                // std::cout << "Plot::CalcScale " << w << " " << h << "\n";
 
                // If user has not called XValues(), set X-axis scale to 1
                if (!myfXset)
                    XUValues(0, 1);
 
                // check there are traces that need to be drawn
                if (!myTrace.size())
                    return false;
 
                // set pixel ranges for the axis
                myYScale.YPrange(h - mypBottomMarginWidth, 10);
                myXScale.xpSet(mypLeftMarginWidth, w - 50);
 
                int ximin, ximax;
                double ymin, ymax;
                switch (myScaleStateMachine.myState)
                {
                case scaleStateMachine::eState::fit:
 
                    calcDataBounds(ximin, ximax, ymin, ymax);
                    myXScale.xiSet(ximin, ximax);
                    myYScale.YVrange(ymin, ymax);
                    myLeftAxis.setValueRange(ymin, ymax);
 
                    break;
 
                case scaleStateMachine::eState::fix:
                    break;
 
                case scaleStateMachine::eState::fitzoom:
                case scaleStateMachine::eState::fixzoom:
                    break;
 
                default:
                    return false;
                }
 
                myXScale.calculate();
                myYScale.calculate();
 
                myBottomAxis.setValueRange(myXScale.XUmin(), myXScale.XUmax());
                myLeftAxis.setValueRange(myYScale.YVmin(), myYScale.YVmax());
 
                // myXScale.text();
 
                return true;
            }
 
        private:
            std::vector<trace *> myTrace;
 
            // scales
            scaleStateMachine myScaleStateMachine;
            XScale myXScale;
            YScale myYScale;
 
            axis myLeftAxis;
            axis myRightAxis;
            axis myBottomAxis;
 
            int mypBottomMarginWidth, mypLeftMarginWidth;
            std::string myXAxisLabel, myYAxisLabel;
 
            bool myfGrid; // true if tick and grid marks reuired
            bool myfXset; // true if the x user range has been set
            bool myfDrag; // drag in progress
 
            int myStartDragX;
            int myStartDragY;
            int myStopDragX;
            int myStopDragY;
 
            void calcDataBounds(
                int &xmin, int &xmax,
                double &ymin, double &ymax)
            {
                myTrace[0]->bounds(
                    xmin, xmax,
                    ymin, ymax);
                for (auto &t : myTrace)
                {
                    int txmin, txmax;
                    double tymin, tymax;
                    txmin = txmax = tymax = 0;
                    tymin = std::numeric_limits<double>::max();
                    t->bounds(txmin, txmax, tymin, tymax);
                    if (txmin < xmin)
                        xmin = txmin;
                    if (txmax > xmax)
                        xmax = txmax;
                    if (tymin < ymin)
                        ymin = tymin;
                    if (tymax > ymax)
                        ymax = tymax;
                }
            }
            void zoomHandler()
            {
                // check if user has completed a good drag operation
                if (!isGoodDrag())
                    return;
 
                // change scale state
                if (myScaleStateMachine.event(
                        scaleStateMachine::eEvent::zoom) ==
                    scaleStateMachine::eState::none)
                {
                    // scale state change failed
                    // probably zoom attempt on already zoomed plot
                    return;
                }
 
                /* set the zoom scale values
 
                The scale calculation, and plot redrawing will be done in the next update() call
                */
 
                myXScale.zoom(myXScale.XP2XU(myStartDragX), myXScale.XP2XU(myStopDragX));
                myYScale.zoom(myYScale.YP2YV(myStopDragY), myYScale.YP2YV(myStartDragY));
            }
            bool isGoodDrag()
            {
                return (myfDrag && myStopDragX > 0 && myStopDragX > myStartDragX && myStopDragY > myStartDragY);
            }
 
            void drawAxis(wex::shapes &S)
            {
                S.color(0xFFFFFF - bgcolor());
                S.textHeight(15);
 
                myLeftAxis.draw(
                    S,
                    myXScale,
                    myYScale);
 
                if (myYAxisLabel.length())
                {
                    S.textVertical();
                    S.text(myYAxisLabel,
                           {mypLeftMarginWidth - 50, myYScale.YPmax() + 30});
                    S.textVertical(false);
                }
                if( myXAxisLabel.length())
                {
                    S.text(myXAxisLabel,
                    {  myXScale.XPmax() -30 , myYScale.YPmin() + 30});
                }
 
                // myRightAxis.draw(
                //     S,
                //     myXScale.XPmax(),
                //     myXScale.XPmax(),
                //     myYScale.YPmax(),
                //     myYScale.YPmin());
 
                myBottomAxis.draw(
                    S,
                    myXScale,
                    myYScale);
            }
 
            void drawTrace(trace *t, shapes &S)
            {
                S.penThick(t->thick());
                S.color(t->color());
 
                bool first = true;
                int xi = 0;
                double prevX, prev;
 
                switch (t->myType)
                {
                case trace::eType::plot:
                {
                    POINT p;
                    std::vector<POINT> vp;
                    for (auto y : t->getY())
                    {
                        // scale
                        p.x = myXScale.XI2XP(xi++);
                        p.y = myYScale.YV2YP(y);
                        vp.push_back(p);
                    }
                    S.polyLine(vp.data(), t->size());
                }
                break;
 
                case trace::eType::scatter:
                {
                    S.fill();
                    int lnght = 10;
                    const double *px = t->getX().data();
                    const double *py = t->getY().data();
                    for (int k = 0; k < t->getY().size(); k++)
                    {
 
                        int x = myXScale.XI2XP(*(px + k));
                        int y = myYScale.YV2YP(*(py + k));
                        S.rectangle(
                            {x - lnght/2, y - lnght/2,
                                lnght, lnght});
                    }
                }
                break;
 
                case trace::eType::realtime:
                {
 
                    for (auto y : t->getY())
                    {
 
                        // scale data point to pixels
                        double x = myXScale.XI2XP(xi++);
                        double yp = myYScale.YV2YP(y);
 
                        if (first)
                        {
                            first = false;
                        }
                        else
                        {
                            // draw line from previous to this data point
                            S.line(
                                {(int)prevX, (int)prev, (int)x, (int)yp});
                        }
 
                        prevX = x;
                        prev = yp;
                    }
                }
                break;
 
                default:
                    throw std::runtime_error(
                        "Trace type NYI");
                }
            }
            void drawSelectedArea(PAINTSTRUCT &ps)
            {
                if (!isGoodDrag())
                    return;
 
                // display selected area by drawing a box around it
                wex::shapes S(ps);
 
                // contrast to background color
                S.color(0xFFFFFF ^ bgcolor());
 
                S.line({myStartDragX, myStartDragY, myStopDragX, myStartDragY});
                S.line({myStopDragX, myStartDragY, myStopDragX, myStopDragY});
                S.line({myStopDragX, myStopDragY, myStartDragX, myStopDragY});
                S.line({myStartDragX, myStopDragY, myStartDragX, myStartDragY});
            }
        };
    }
}