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));
            }
 
            int XUmin() const
            {
                return xumin;
            }
            int 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)
            {
                yvminFit = min;
                yvmaxFit = max;
            }
 
            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);
            }
            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;
            }
        };
 
        // @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 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> &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 plot : public gui
        {
        public:
            plot(gui *parent)
                : gui(parent), myfDrag(false),
                  myXScale(myScaleStateMachine),
                  myYScale(myScaleStateMachine)
            {
                text("Plot");
 
                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
                        drawYAxis(S);
                        drawXAxis(
                            S,
                            ps.rcPaint.bottom - 20);
 
                        // 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(
                    [&]
                    {
                        // check if user has completed a good drag operation
                        if (isGoodDrag())
                        {
                            // check for valid event
                            if (myScaleStateMachine.event(scaleStateMachine::eEvent::zoom) != scaleStateMachine::eState::none)
                            {
                                double myZoomXMin = myXScale.XP2XU(myStartDragX);
                                double myZoomXMax = myXScale.XP2XU(myStopDragX);
                                double myZoomYMax = myYScale.YP2YV(myStartDragY);
                                double myZoomYMin = myYScale.YP2YV(myStopDragY);
 
                                myXScale.zoom(myZoomXMin, myZoomXMax);
                                myYScale.zoom(myZoomYMin, myZoomYMax);
 
                                // myfZoom = true;
 
                                // std::cout << myStartDragX <<" "<< myStopDragX <<" "<< myStartDragY <<" "<< myStopDragY << "\n";
                                // std::cout << myZoomXMin <<" "<< myZoomXMax <<" "<< myZoomYMin <<" "<< myZoomYMax << "\n";
                            }
                        }
                        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;
            }
 
 
            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");
            }
 
            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);
            }
 
            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 - 40, 10);
                myXScale.xpSet(50, w - 70);
 
                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);
                    break;
 
                case scaleStateMachine::eState::fix:
                    calcDataBounds(ximin, ximax, ymin, ymax);
                    myXScale.xiSet(ximin, ximax);
                    break;
 
                case scaleStateMachine::eState::fitzoom:
                case scaleStateMachine::eState::fixzoom:
                    break;
 
                default:
                    return false;
                }
 
                myXScale.calculate();
                myYScale.calculate();
 
                // myXScale.text();
 
                return true;
            }
 
            std::vector<trace *> &traces()
            {
                return myTrace;
            }
 
            // bool isZoomed() const
            // {
            //     return myfZoom;
            // }
 
            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);
            }
 
        private:
            std::vector<trace *> myTrace;
 
            // scales
            scaleStateMachine myScaleStateMachine;
            XScale myXScale;
            YScale myYScale;
 
            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;
                }
            }
            bool isGoodDrag()
            {
                return (myfDrag && myStopDragX > 0 && myStopDragX > myStartDragX && myStopDragY > myStartDragY);
            }
 
            std::vector<double> ytickValues()
            {
                std::vector<double> vl;
                double mn = myYScale.YPmax();
                double mx = myYScale.YPmin();
                double range = mx - mn;
                if (range < minDataRange)
                {
                    // plot is single valued
                    // display just one tick
                    vl.push_back(mn);
                    return vl;
                }
                double inc = myYScale.YVrange() / 4;
                double tickValue;
                if (inc > 1)
                {
                    inc = (int)inc;
                    tickValue = myYScale.YP2YV(myYScale.YPmin());
                }
                else
                {
                    tickValue = mn;
                }
                // if (tick < 0)
                //     return vl;
 
                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 += inc;
                    if (tickValue >= mx)
                        break;
                }
                vl.push_back(mx);
                return vl;
            }
            std::string numberformat(double f)
            {
                if (f == 0)
                {
                    return "0";
                }
                int n = 2;                                         // 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();
            }
            void drawYAxis(wex::shapes &S)
            {
                S.color(0xFFFFFF - bgcolor());
                S.textHeight(15);
 
                S.line({50, myYScale.YPmin(),
                        50, myYScale.YPmax()});
 
                for (double y : ytickValues())
                {
                    int yp = myYScale.YV2YP(y);
                    S.text(numberformat(y),
                           {0, yp - 8, 50, 15});
                    S.line({50, yp,
                            60, yp});
                    if (myfGrid)
                    {
                        auto kpmax = myXScale.XPmax();
                        for (int kp = 65;
                             kp < kpmax;
                             kp += 25)
                        {
                            S.pixel(kp, yp);
                            S.pixel(kp + 1, yp);
                        }
                    }
                }
                // int yp = scale::get().Y2Pixel(mx);
                //  S.text(myMaxYLabel,
                //         {0, yp + 10, 50, 15});
            }
            void drawXAxis(wex::shapes &S, int ypos)
            {
                S.color(0xFFFFFF - bgcolor());
                S.textHeight(15);
                S.line({myXScale.XPmin(), ypos, myXScale.XPmax(), ypos});
                if (!myfGrid)
                {
                    // there is no grid
                    // so just label the minimum, maximum x points
                    float xmin_label_value = 0;
                    float xmax_label_value = 100;
                    if (myfXset)
                    {
                        xmin_label_value = myXScale.XUmin();
                        xmax_label_value = myXScale.XUmax();
                    }
                    S.text(std::to_string((int)xmin_label_value), {myXScale.XPmin(), ypos + 3, 50, 15});
                    S.text(std::to_string((int)xmax_label_value), {myXScale.XPmax() - 25, ypos + 3, 50, 15});
                    return;
                }
                // there is a grid
 
                int tickCount = 8;
                float xutickinc = (myXScale.XUmax() - myXScale.XUmin()) / tickCount;
 
                // std::cout << "X ticks ";
                // myXScale.text();
                // std::cout
                //     << " xutickinc " << xutickinc
                //     << "\n";
 
                // if possible, place tick marks at integer values of x index
                if (xutickinc > 1)
                    xutickinc = floor(xutickinc);
 
                for (int kxtick = 0; kxtick <= tickCount; kxtick++)
                {
                    float tickXU = myXScale.XUmin() + kxtick * xutickinc;
                    // float tick_label_value = myXScale.XI2XU(tickXU);
                    int xPixel = myXScale.XU2XP(tickXU);
 
                    // std::cout << "tick " << kxtick << " xu " << tickXU
                    //           << " " << xPixel << "\n";
 
                    S.text(
                        std::to_string(tickXU).substr(0, 4),
                        {xPixel, ypos + 1, 50, 15});
 
                    for (
                        int k = myYScale.YPmax();
                        k < myYScale.YPmin();
                        k = k + 25)
                    {
                        S.pixel(xPixel, k);
                        S.pixel(xPixel, k + 1);
                    }
                }
            }
            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:
 
                    for (auto y : t->getY())
                    {
                        S.rectangle(
                            {myXScale.XI2XP(xi++) - 5, myYScale.YV2YP(y) - 5,
                             5, 5});
                    }
                    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});
            }
        };
    }
}