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

---

RotorDoDView.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef Impala_Visualzation_RotorBrowser_RotorDoDView_h
#define Impala_Visualzation_RotorBrowser_RotorDoDView_h

#ifndef OglGui_View
#include "OglGui/View.h"
#endif

#ifndef OglGui_Window
#include "OglGui/Window.h"
#endif

namespace Impala {
namespace Visualization {
namespace RotorBrowser {

using namespace OglGui;

class RectangleListener
{
public:
    virtual void
    OnRectangleSelect(float x, float y, float w, float h) = 0;
};

class RotorDoDView : public OglGui::View
{
public:
    RotorDoDView(OGLWND* oglWnd, OGLIMAGE *oglIm, float x, float y, float z,
                 float w, float h, float d, ViewListener* li=0) :
        OglGui::View(oglWnd, oglIm, x, y, z, w, h, d, li)
    {
        // ILOG_DEBUG("RotorDoDView()");;
        // SetTags(FlexViewTags);
        mIsDragging         = false;
        mRotorView          = NULL;
        mObscure            = 0;
        mPositiveAlpha      = 0;
        mNegativeAlpha      = 0;
        mProbabilityAlpha   = 0;
    }

    void SetObscure(float a)         { mObscure = a; }
    void PositiveAlpha(float a)      { mPositiveAlpha = a; } 
    void NegativeAlpha(float a)      { mNegativeAlpha = a; } 
    void ProbabiltyAlpha(float a)    { mProbabilityAlpha = a; } 

    void LeftCornerTriangle(int r, int g, int b, int a)
    {
        if (a <= 0.f) return;
        INT bInfo[3];
        oglSys.StartBlend(bInfo);
        OGCSetPolyFillMode(theOGC,3);
        ULONG col = RGBA2COLOR(r,g,b,a);
        SetSolidFillColor(col);
        OGLVIEW3D* v3D = GetOGLVIEW3D();
        float x = -v3D->w/2;
        float y = -v3D->h/2;
        float coords[6];
        coords[0] = x;
        coords[1] = y;
        coords[2] = x + v3D->w/2;
        coords[3] = y;
        coords[4] = x;
        coords[5] = y + v3D->h/2;
        FillTriangles(coords,3);
        oglSys.EndBlend(bInfo);
    }

    void HandleObscure()
    {
        if (mObscure <= 0.f) return;
        INT bInfo[3];
        oglSys.StartBlend(bInfo);
        int alpha = mObscure * 255;
        ULONG col = RGBA2COLOR(64,64,64,alpha);
        SetSolidFillColor(col);
        OGLVIEW3D* v3D = GetOGLVIEW3D();
        float x = -v3D->w/2+0.01;
        float y = -v3D->h/2+0.01;
        FillRectangle3D(x,y,0.01,v3D->w-0.02,v3D->h-0.02);
        oglSys.EndBlend(bInfo);
    }

    void HandleProbability()
    {
        // TODO implement
    }

    void HandlePositiveNegative()
    {
        glPushMatrix();
        glTranslatef(0,0,0.02);
        LeftCornerTriangle(0,255,0,mPositiveAlpha*255);
        LeftCornerTriangle(255,0,0,mNegativeAlpha*255);
        glPopMatrix();
    }

    void HandleDragRect()
    {
        if (!mIsDragging) return;

        OGC prevOGC;
        OGCSave( &prevOGC );
        SetLineWidth(2);
        SetSolidLineColor(0xffdddd22);
        DrawRectangle3D(mDragLX,mDragLY,0.01,mDragHX-mDragLX,mDragHY-mDragLY);
        OGCRestore( &prevOGC );
    }

    // allow for rectangle-based selecting in 3D:
    virtual void OnMouse(int msg, int btn, int state, float x, float y)
    {
        OglGui::View::OnMouse(msg, btn, state, x, y);
        float h = mView3D->h;
        float w = mView3D->w;

        if (msg == oglMouseDown && btn == oglLeftButton)
        {
            if (mIsDragging)
            {
                // execute if click within box, cancel if outside:
                if (mDragLX<=x && x<=mDragHX && mDragLY<=y && y<=mDragHY)
                {
                    float sx, sy, sw, sh;
                    sx = mDragLX/w;
                    sy = mDragLY/h;
                    sw = (mDragHX - mDragLX)/w;
                    sh = (mDragHY - mDragLY)/h;
                    if (mRotorView && sw > 1 && sh > 1)
                        mRotorView->OnRectangleSelect(sx,1.0-(sy+sh),sw,sh);
                }
                mIsDragging = false;
            }
            else
            {
                mDragLX = mDragHX = x;
                mDragLY = mDragHY = y;
                mIsDragging = true;
            }
        }
        if (msg == oglMouseMove && mIsDragging)
        {
            if (x < mDragLX) mDragLX = x;
            if (x > mDragHX) mDragHX = x;
            if (y < mDragLY) mDragLY = y;
            if (y > mDragHY) mDragHY = y;

            if (mDragLX < -w/2) mDragLX = -w/2;
            if (mDragLY < -h/2) mDragLY = -h/2;
            if (mDragHX > w/2)  mDragHX = w/2;
            if (mDragHY > h/2)  mDragHY = h/2;
        }
    }

    virtual void OnDrawView()
    {
        OglGui::View::OnDrawView();
        HandleObscure();
        HandlePositiveNegative();
        HandleProbability();
        HandleDragRect();
    }

    virtual void OnSelection(bool selected)
    {
        OglGui::View::OnSelection(selected);
        ILOG_DEBUG("OnSelection(" << selected <<")");
    }

    void SetCurrentRotorView(RectangleListener *rv)
    {
        mRotorView = rv;
        mIsDragging = false; // reset rectangle when RotorView changes
    }

    /* checks if this View's image resolution is the same as
       a given resolution, used in MDViewCache */
    bool HasResolution(int w, int h)
    {
        if (!mView3D->im) return false;
        return h == mView3D->im->h && w == mView3D->im->w;
    }

    float                   mDragLX, mDragHX;
    float                   mDragLY, mDragHY;
    bool                    mIsDragging;

    float                   mObscure;
    float                   mPositiveAlpha;
    float                   mNegativeAlpha;
    float                   mProbabilityAlpha;

    RectangleListener*      mRotorView;

    ILOG_VAR_DEC;

}; // class RotorDoDView

ILOG_VAR_INIT(RotorDoDView, Visualization.RotorBrowser);

}
}
}

#endif

---