|| || || || || || || ||

---

Plot.h

Go to the documentation of this file.

#ifndef Impala_Visualisation_Plot_Plot_h
#define Impala_Visualisation_Plot_Plot_h

#include "Core/Array/Arrays.h"
#include "OglGui/Window.h"
#include "Visualization/Plot/Plottable.h"

namespace Impala
{
namespace Visualization
{
namespace Plot
{


class Plot : public OglGui::Window
{
public:
    Plot(OglGui::Window* parent, int x, int y, int width, int height) : 
        OglGui::Window(parent, x, y, width, height)
    {
        Init();
        //mPerspective = true;
    }

    Plot(OglGui::Window* parent, int width, int height) : 
        OglGui::Window(parent, width, height)
    {
        Init();
        //mPerspective = true;
    }

    void Add(Plottable* p)
    {
        mPlottables.push_back(p);
    }

    void SetCenter(double x, double y, double z)
    {
        mCenter[0] = x;
        mCenter[1] = y;
        mCenter[2] = z;
    }

    void SetRange(double x, double y, double z)
    {
        double w=1., h=1.;
        if(mDrawAxes)
        {
            //reserve space for axes and text
            w = mOglWnd->width * 0.5;
            w = w/(w-20.0);
            h = mOglWnd->height * 0.5;
            h = h/(h-20.0);
        }
        mRange[0] = x*w;
        mRange[1] = y*h;
        mRange[2] = z;
    }

    void GetRange(double& left, double& top, double& right, double& bottom)
    {
        Pixel2Window(20, 20, left, bottom);
        Pixel2Window(mOglWnd->width-20, mOglWnd->height-20, right, top);
    }

    bool IsVisible(double x, double y)
    {
        double pixX, pixY;
        Window2Pixel(x,y,pixX,pixY);
        return !(pixX < 0 || pixX > W() || pixY < 0 || pixY > H());
    }

    void MakeVisibleAtPix(double x, double y, double pixX, double pixY)
    {
        double atX, atY;
        Window2Pixel(x,y,atX,atY);
        mUserPan[0] += (pixX - atX)* mRange[0] / ((double)mOglWnd->width *mUserZoom[0]);
        mUserPan[1] += (pixY - atY)* mRange[1] / ((double)mOglWnd->height*mUserZoom[1]);
    }

    void GetUserPan(double& panX, double& panY)
    {
        panX = mUserPan[0];
        panY = mUserPan[1];
    }

    void SetUserPan(double panX, double panY)
    {
        mUserPan[0] = panX;
        mUserPan[1] = panY;
    }

    void GetUserZoom(double& zoomX, double& zoomY)
    {
        zoomX = mUserZoom[0];
        zoomY = mUserZoom[1];
    }

    void SetUserZoom(double zoomX, double zoomY)
    {
        mUserZoom[0] = zoomX;
        mUserZoom[1] = zoomY;
    }

    void GetRotations(double& roll, double& pitch, double& yaw)
    {
        roll = mRoll;
        pitch = mPitch;
        yaw = mYaw;
    }

    //void SetPerspective(bool flag)
    //{
    //    mPerspective = flag;
    //}

    void SetDrawAxes(bool flag)
    {
        mDrawAxes = flag;
    }

    bool GetDrawAxes()
    {
        return mDrawAxes;
    }
    void Window2Pixel(double wx, double wy, double&px, double& py)
    {
        wx -= mCenter[0]-mUserPan[0]-(.5*mRange[0]/mUserZoom[0]);
        px = wx / ((mRange[0]/mUserZoom[0])/(double)mOglWnd->width);
        wy -= mCenter[1]-mUserPan[1]-(.5*mRange[1]/mUserZoom[1]);
        py = wy / ((mRange[1]/mUserZoom[1])/(double)mOglWnd->height);
    }

    void Pixel2Window(double px, double py, double&wx, double& wy)
    {
        wx = (px*mRange[0]/mUserZoom[0])/(double)mOglWnd->width;
        wx += mCenter[0]-mUserPan[0]-(.5*mRange[0]/mUserZoom[0]);
        wy = (py*mRange[1]/mUserZoom[1])/(double)mOglWnd->height;
        wy += mCenter[1]-mUserPan[1]-(.5*mRange[1]/mUserZoom[1]);
    }

    void AutoScale()
    {
        if(mPlottables.size() == 0)
            return;
        double minx, maxx;
        double miny, maxy;
        double minz, maxz;
        Plottable* p;
        p = mPlottables[0];
        p->GetDimensionsX(minx, maxx);
        p->GetDimensionsY(miny, maxy);
        p->GetDimensionsZ(minz, maxz);
        for(int i=1 ; i<mPlottables.size() ; i++)
        {
            double min, max;
            p = mPlottables[i];
            p->GetDimensionsX(min, max);
            if(min<minx)
                minx = min;
            if(max>maxx)
                maxx = max;
            p->GetDimensionsY(min, max);
            if(min<miny)
                miny = min;
            if(max>maxy)
                maxy = max;
            p->GetDimensionsZ(min, max);
            if(min<minz)
                minz = min;
            if(max>maxz)
                maxz = max;
        }

        if(minz == maxz)
        {
            minz = -1;
            maxz = 1;
            mIs3d = false;
        }
        else
            mIs3d = true;

        SetCenter((maxx+minx)*.5, (maxy+miny)*.5, (maxz+minz)*.5);
        SetRange(maxx-minx, maxy-miny, maxz-minz);
    }

    //void TransformMatrices(double w, double h)
    //{
    //    //projection
    //    glMatrixMode(GL_PROJECTION);
    //    glPushMatrix();
    //    glLoadIdentity();
    //    if (mPerspective)
    //        gluPerspective(45, w/h, 1, 8);
    //    else
    //        glOrtho(-1, 1, -1, 1, 1, 7);

    //    //model
    //    glMatrixMode(GL_MODELVIEW);
    //    glPushMatrix();
    //    glLoadIdentity();
    //    glTranslatef(0,0,-4.5);

    //    glRotatef(mRoll + mUserRoll, 1, 0, 0);
    //    glRotatef(mPitch + mUserPitch, 0, 1, 0);
    //    glRotatef(mYaw, 0, 0, 1);

    //    glScaled(2.*mUserZoom[0]/mRange[0], 2.*mUserZoom[1]/mRange[1], 2./mRange[2]);
    //    glTranslated(-mCenter[0]+mUserPan[0], -mCenter[1]+mUserPan[1], -mCenter[2]);
    //}

    void TransformMatrices(double w, double h)
    {
        //******NOTE: this implementation is for 2D only*******//
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();

        double range[2];
        double center[2];
        for(int i=0 ; i<2 ; ++i)
        {
            center[i] = mCenter[i] - mUserPan[i];
            range[i] = 0.5*mRange[i] / mUserZoom[i];
        }

        glOrtho(center[0] - range[0],
                center[0] + range[0],
                center[1] - range[1],
                center[1] + range[1],
                -1, 1);

        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
    }

    virtual void DisplayFunc()
    {
        OGC oldOGC;
        OGCSave(&oldOGC);
        TransformMatrices(mOglWnd->width, mOglWnd->height);

        if(mDrawAxes)
            DrawAxes();

        for (int i=0 ; i<mPlottables.size() ; i++)
        {
            mPlottables[i]->Draw(this);
        }


        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();

        OGCRestore(&oldOGC);
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        bool shift = (state & oglShift) != 0;
        bool control = (state & oglControl) != 0;

        if (msg == oglMouseDown && but == oglRightButton) 
        {
            //if(control)
            //    mPerspective = !mPerspective;
            //else
            {
                for(int i=0 ; i<2 ; i++)
                {
                    mUserPan[i] = 0;
                    mUserZoom[i] = 0.9;
                }
                mUserRoll = mUserPitch = 0;
            }
        }

        if (msg == oglMouseDown && but == oglLeftButton && (shift||control)) 
        {
            mDragging = true;
            mClickX = x;
            mClickY = y;
        }

        if (msg == oglMouseUp) 
            mDragging = false;
    
        if (msg == oglMouseMove && mDragging)
        {
            int dx = x - mClickX;
            int dy = y - mClickY;
            if(control)
            {
                mUserZoom[0] *= pow(1.02,(double)dx);
                mUserZoom[1] *= pow(1.02,(double)dy);
                for(int i=0 ; i<2 ; i++)
                    if(mUserZoom[i] < 0.01)
                        mUserZoom[i] = 0.01;
            }
            else
                //if(mPerspective && !control)
                //{
                //    mUserRoll -= dy;
                //    if(mUserRoll > 90)
                //        mUserRoll = 90;
                //    if(mUserRoll < -90)
                //        mUserRoll = -90;
                //    mUserPitch += dx;
                //}
                //else
                {
                    mUserPan[0] += (double)dx * mRange[0] / ((double)mOglWnd->width *mUserZoom[0]);
                    mUserPan[1] += (double)dy * mRange[1] / ((double)mOglWnd->height*mUserZoom[1]);
                }
            mClickX = x;
            mClickY = y;
        }
    
        double wx, wy;
        Pixel2Window(x, y, wx, wy);
        for(int i=0 ; i<mPlottables.size() ; i++)
            mPlottables[i]->OnMouse(wx, wy, msg, but, state);
    }

protected:
    double mRoll, mPitch, mYaw;
    double mUserRoll, mUserPitch;
    std::vector<Plottable*> mPlottables;
    bool mDragging;
    //bool mPerspective;
    bool mDrawAxes;
    bool mIs3d;
    int mClickX, mClickY;

    double mCenter[3];
    double mRange[3]; // means either distance from center to edge, or from min to max, TBD
    double mUserZoom[2];
    double mUserPan[2];
    int    mFontBase;

    void Init()
    {
        for(int i=0 ; i<3 ; i++)
        {
            mCenter[i] = 0;
            mRange[i] = 2;
        }
        for(int i=0 ; i<2 ; i++)
        {
            mUserZoom[i] = 0.9;
            mUserPan[i] = 0;
        }
        mRoll = mPitch = mYaw = 0;
        mUserRoll = mUserPitch = 0;
        mOglWnd->bgCol = 0xff505050;
        mDrawAxes = false;
        mDragging = false;
        SetIs2d(false);
        mIs3d = false;

        mFontBase = 0;
    }

    class Axis
    {
    public:
        void SetRange(double min, double max)
        {
            mMin = min;
            mMax = max;
            ComputeTicks();
        }

        double GetTick(int count)
        {
            return (double)(count+mFirstTick)*mTickSize;
        }

        int GetTickCount()
        {
            return mTickCount;
        }

        void DrawRulers(double* start, double* end, int axis)
        {
            double a[3];
            double b[3];
            int i;
            for(i=0 ; i<3 ; i++)
            {
                a[i] = start[i];
                b[i] = end[i];
            }
            glColor3d(.7,.7,.7);
            glBegin(GL_LINES);
            for(i=0 ; i<mTickCount ; i++)
            {
                a[axis] = b[axis] = GetTick(i);
                glVertex3dv(a);
                glVertex3dv(b);
            }
            glEnd();
        }

    private:
        void ComputeTicks()
        {
            double range = mMax - mMin;
            double order = floor(log10(range));
            mTickSize = pow(10.,order);
            double quanta[6] = {.2, .4, .5, .75, 1., 2.};
            double quantum = 1.;
            for(int i=0 ; i<6 ; i++)
            {
                if(range / (quanta[i]*mTickSize) >= 4)
                    quantum = quanta[i];
            }
            mTickSize *= quantum;
            mFirstTick = ceil(mMin / mTickSize);
            mTickCount = floor(mMax / mTickSize) - mFirstTick + 1;
        }

        double mMin, mMax;
        int mFirstTick;
        int mTickCount;
        double mTickSize;
    };
    Axis mAxisX;
    Axis mAxisY;
    Axis mAxisZ;

    void UpdateAxes()
    {
        double x1,x2,y1,y2;
        Pixel2Window(20, 20, x1, y1);
        Pixel2Window(mOglWnd->width-20, mOglWnd->height-20, x2, y2);
        mAxisX.SetRange(x1, x2);
        mAxisY.SetRange(y1, y2);
    }

    void DrawAxes()
    {
        UpdateAxes();
        if (!mFontBase)
            FindOglFont(mOglWnd, 0, &mFontBase);

        glColor3d(1,1,0);
        double x1,y1,tick;
        Pixel2Window(4, 4, x1, y1);

        int i;
        for(i=0 ; i<mAxisX.GetTickCount() ; i++)
        {
            tick = mAxisX.GetTick(i);
            glRasterPos3d(tick, y1, 0);
            std::ostringstream os;
            os << tick;
            oglSys.PrintFont(mFontBase, (char*) os.str().c_str());
        }
        for(i=0 ; i<mAxisY.GetTickCount() ; i++)
        {
            tick = mAxisY.GetTick(i);
            glRasterPos3d(x1, tick, 0);
            std::ostringstream os;
            os << tick;
            oglSys.PrintFont(mFontBase, (char*) os.str().c_str());
        }

        double x2,y2;
        Pixel2Window(20, 20, x1, y1);
        Pixel2Window(mOglWnd->width-20, mOglWnd->height-20, x2, y2);
        glBegin(GL_LINE_STRIP);
        glVertex2d(x2,y1);
        glVertex2d(x1,y1);
        glVertex2d(x1,y2);
        glEnd();

        glColor3d(0.6,0.6,0);
        glBegin(GL_LINES);
        for(i=0 ; i<mAxisX.GetTickCount() ; i++)
        {
            tick = mAxisX.GetTick(i);
            glVertex3d(tick, y1, 0);
            glVertex3d(tick, y2, 0);
        }
        for(i=0 ; i<mAxisY.GetTickCount() ; i++)
        {
            tick = mAxisY.GetTick(i);
            glVertex3d(x1, tick, 0);
            glVertex3d(x2, tick, 0);
        }
        glEnd();
    
    }
};


}//namespace Impala
}//namespace Visulization
}//namespace Plot

/*
*/
#endif

---