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

---

View.h

Go to the documentation of this file.

#ifndef Impala_Visualization_View_h
#define Impala_Visualization_View_h

#include "Core/Array/Arrays.h"
#include "Core/Array/GetRgbPixels.h"
#include "OglGui/View.h"
#include "Core/Geometry/Rectangle.h"

namespace Impala
{
namespace Visualization
{


class View : public OglGui::View
{
public:
    typedef Core::Array::Array2dVec3UInt8 Array2dVec3UInt8;

    // 2d view
    View(OGLWND* oglWnd, int x, int y, int imW, int imH,
         double scale, bool texturing, bool noTexScaling, bool keepDispImage,
         OglGui::ViewListener* listener = 0) :
         OglGui::View(oglWnd, InitOGLIMAGE(imW, imH, texturing, noTexScaling,
                                          keepDispImage), x, y, scale*imW,
                     scale*imH, listener)
    {
// RvB: Experiment: Note strange things happen when noTexScaling and texturing true
//        texturing = true;
//        noTexScaling = true;
        //OGLIMAGE* oglIm = InitOGLIMAGE(imW, imH, texturing, noTexScaling,
        //                               keepDispImage);

        viewSys.SetZoom(mView2D, scale, scale);
        viewSys.SetTags(mView2D, sTags);
        //viewSys.SetUpsideDown(mView2D, 1);
        if (mTexturing)
            viewSys.SetTexturing(mView2D, 1);

        oglSys.ReleaseOglImage(mOglIm); // mOglIm was set by InitOGLIMAGE
        mOglIm = 0;

        mPointerX = -1;
        mPointerDrag = false;
    }

    // 3d view
    View(OGLWND* oglWnd, float x, float y, float z, int imW, int imH,
         double scaleX, double scaleY, bool noTexScaling,
         bool keepDispImage, OglGui::ViewListener* listener = 0) :
        OglGui::View(oglWnd, InitOGLIMAGE(imW, imH, true, noTexScaling,
                                          keepDispImage), x, y, z,
                     scaleX, scaleY, 1.0f, listener)
    {
        view3DSys.SetZoom(mView3D, scaleX, scaleY);
        view3DSys.SetTags(mView3D, sTags );

        oglSys.ReleaseOglImage(mOglIm); // mOglIm was set by InitOGLIMAGE
        mOglIm = 0;

        mPointerX = -1;
        mPointerDrag = false;
    }

    // deprecated. Use OglGui::View::SetZoom
    /*
    void
    SetScale2d(double scale_x, double scale_y)
    {
        viewSys.SetZoom(mView2D, scale_x, scale_y);
    }
    */

    // todo : move this to OglGui::View
    void
    SetText(std::string text)
    {
        if (mIs2D)
        {
            viewSys.SetStr(mView2D, OGL_TEXT, (char*) text.c_str());
            viewSys.SetTags(mView2D, showTextTag);
        }
    }

    // No longer neccesary here as already placed
    // in OglGui::View.h
    void
    SetTagsTo(int tags, bool mode)
    {
        if (mIs2D)
        {
            if (mode)
                viewSys.SetTags(mView2D, tags);
            else
                viewSys.ClearTags(mView2D, tags);
        }
        else
        {
            if (mode)
                view3DSys.SetTags(mView3D, tags);
            else
                view3DSys.ClearTags(mView3D, tags);
        }
    }

    bool
    AreTagsOn(int tags)
    {
        if (mIs2D)
            return viewSys.HasTags(mView2D, tags) ? true : false;
        else
            return view3DSys.HasTags(mView3D, tags) ? true : false;
    }

    void
    SetVisible(bool mode)
    {
        SetTagsTo(visibleTag, mode);
    }

    bool
    GetVisible()
    {
        return AreTagsOn(visibleTag);
    }

    void
    SetBorderCol(ULONG color)
    {
        if (mIs2D)
            viewSys.SetColor(mView2D, OGL_BORDER, color);
    }

    void
    UpdateImage(unsigned char* dataPtr)
    {
        OGLIMAGE* oglIm = GetImage();
 // RvB: 3-2-2009 mem leak
ReleaseOglImage(oglIm);
        Array2dVec3UInt8* dispIm = (Array2dVec3UInt8*) oglIm->imageHandle;
       if (!dispIm)
            return;
        int nBytes = dispIm->CW() * dispIm->CH() * 3;
        memcpy(dispIm->CPB(0, 0), dataPtr, nBytes);
        DoUpdateDispImage(oglIm);
    }

    template <class ArrayT>
    void
    UpdateImage(ArrayT* im, std::string displayMode)
    {
        OGLIMAGE* oglIm = GetImage();
// RvB: 3-2-2009 mem leak
ReleaseOglImage(oglIm);
        Array2dVec3UInt8* dispIm = (Array2dVec3UInt8*) oglIm->imageHandle;
        if (!dispIm)
            return;
        if ((dispIm->CW() != im->CW()) || (dispIm->CH() != im->CH()))
        {
            delete dispIm;
            dispIm = Core::Array::ArrayCreate<Array2dVec3UInt8>(im->CW(),
                                                                im->CH(), 0, 0);
            oglIm->imageHandle = dispIm;
        }
        Core::Array::GetRgbPixels(im, dispIm->CPB(0, 0), displayMode);
        DoUpdateDispImage(oglIm);
    }

    void
    SetUpdateOglImage()
    {
        OGLIMAGE* oglIm = GetImage();
// RvB: 3-2-2009 mem leak
ReleaseOglImage(oglIm);
        if (!oglIm)
            return;
        oglIm->changed = 1;
    }

    Array2dVec3UInt8*
    GetDispImage()
    {
        OGLIMAGE* oglIm = GetImage();
// RvB: 3-2-2009 mem leak
ReleaseOglImage(oglIm);
        if (!oglIm)
            return 0;
        return (Array2dVec3UInt8*) oglIm->imageHandle;
    }

    static void
    SetTags(unsigned int tags)
    {
        sTags = tags;
    }

    int
    GetPointerX() const
    {
        return mPointerX;
    }

    int
    GetPointerY() const
    {
        return mPointerY;
    }

    Core::Geometry::Rectangle
    GetPointerDragRect() const
    {
        return Core::Geometry::Rectangle(mPointerX, mPointerY, mPointerDragX,
                                     mPointerDragY);
    }

    virtual void
    OnMouse(int msg, int btn, int state, float x, float y)
    {
        OglGui::View::OnMouse(msg, btn, state, x, y);
        if (msg == oglMouseUp)
            mPointerDrag = false;
        ViewToIm(x, y, mPointerX, mPointerY);
        if ((msg == oglMouseDown) && (btn == oglLeftButton))
        {
            mPointerDrag = true;
            mPointerDragX = mPointerX;
            mPointerDragY = mPointerY;
        }
    }

    /* RvB: This one was not adjusted to new signature. See above
    virtual void
    OnMouse(int msg, int btn, int state, int x, int y)
    {
        OglGui::View::OnMouse(msg, btn, state, x, y);
        if (msg == oglMouseUp)
            mPointerDrag = false;
        ViewToIm(x, y, mPointerX, mPointerY);
        if ((msg == oglMouseDown) && (btn == oglLeftButton))
        {
            mPointerDrag = true;
            mPointerDragX = mPointerX;
            mPointerDragY = mPointerY;
        }
    }
    */

    int 
    W()
    {   
        int x,y,w,h;
        GetDimensions2D(&x, &y, &w, &h);
        return w;
    }

    int 
    H()
    {   
        int x,y,w,h;
        GetDimensions2D(&x, &y, &w, &h);
        return h;
    }

protected:

    OGLIMAGE*
    InitOGLIMAGE(int imW, int imH, bool texturing, bool noTexScaling,
                 bool keepDispImage)
    {
        mTexturing = texturing;
        mNoTexScaling = noTexScaling;
        mKeepDispImage = keepDispImage;

        mOglIm = oglSys.OglImage(GL_RGB, imW, imH);
        mOglIm->imDataFunc = MyOglImdataFunc;
        mOglIm->onDestroy = MyOglImdataDestroyFunc;
        if (mNoTexScaling)
            mOglIm->noTexScaling = 1;
        Array2dVec3UInt8* ar =
            Core::Array::ArrayCreate<Array2dVec3UInt8>(imW, imH, 0, 0);
        mOglIm->imageHandle = ar;
        return mOglIm;

    }

    // RvB: LoadGLtexture is only meaningful if texturing
    // So keepDispImage==false can only be used in 2D when texturing
    void
    DoUpdateDispImage(OGLIMAGE* oglIm)
    {
        oglIm->changed = 1;
        if (!mKeepDispImage)
        {
            oglSys.LoadGLTexture(oglIm);
            oglIm->changed = 0;
            Array2dVec3UInt8* dispIm = (Array2dVec3UInt8*) oglIm->imageHandle;
            delete dispIm;
            oglIm->imageHandle = 0;
        }
    }

    // In 2D without texturing, this function is called once per "event" cycle.
    // In 3D and with texturing, it is called only when oglIm->changed == 1.
    static void*
    MyOglImdataFunc(OGLIMAGE* oglIm)
    {
        // Obtain our 'im' stored as 'imageHandle'
        Array2dVec3UInt8* ar = (Array2dVec3UInt8 *) oglIm->imageHandle;

        // Set oglIm dimensions to our 'im' dimensions
        oglIm->w = ar->CW();
        oglIm->h = ar->CH();
        oglIm->changed = 0;

        return (void *) ar->CPB(0, 0); // Pointer to the image pixels
    }

    static void
    MyOglImdataDestroyFunc(OGLIMAGE* oglIm)
    {
        if (!oglIm)
            return;
        Array2dVec3UInt8* ar = (Array2dVec3UInt8 *) oglIm->imageHandle;
        if (ar)
            delete ar;
    }

private:

    OGLIMAGE* mOglIm; // temporary variable for InitOGLIMAGE
    bool      mTexturing;
    bool      mNoTexScaling;
    bool      mKeepDispImage; //if false, destroy disp image after first update
                              //only(?) possible if (noTexScaling)

    int   mPointerX; // position of mouse pointer, in image coordinates
    int   mPointerY;
    int   mPointerDragX; // position of last MouseDown
    int   mPointerDragY;
    bool  mPointerDrag;

    static unsigned int sTags;

};

unsigned int View::sTags = 
    selectableTag | showBgTag | showBorderTag | movableTag | sizableTag |
    showBorderTag | panableTag | zoomableTag | showTitleTag | rotatableTag;

} // namespace Visualization
} // namespace Impala

#endif

---