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

---

VidolviView.h

Go to the documentation of this file.

#ifndef Impala_Application_Videolympics_VidolviView_h
#define Impala_Application_Videolympics_VidolviView_h

#include "Basis/CmdOptions.h"
#include "Core/ImageSet/ImageSet.h"
#include "Core/Array/Arrays.h"
#include "Core/Geometry/Rectangle.h"
#include "OglGui/View.h"
#include "OglGui/Window.h"
#include "Core/Array/Arrays.h"

#include "PhysicsEngine.h"

namespace Impala {
namespace Application {
namespace Videolympics {

using namespace OglGui;

class VidolviView : public OglGui::View
{
public:
    VidolviView(OGLWND* oglWnd, Core::Array::Array2dVec3UInt8 *image, float x, float y, float z,
           float w, float h, float d, ViewListener* li=0):
        OglGui::View(oglWnd, InitOGLIMAGE(image), x, y, z, w, h, d, li)
    {
        static int viewnr = 0;
        mViewNr = viewnr;
        viewnr++;
        view3DSys.SetTags(GetOGLVIEW3D(), FlexViewTags);
        view3DSys.SetZoom(GetOGLVIEW3D(), 2.2f, 1.4f);
//        view3DSys.SetZoom(GetOGLVIEW3D(), w, h);
//        view3DSys.SetObject3D(GetOGLVIEW3D(), 2);
        oglSys.ReleaseOglImage(mOglIm);
        mPPart = new PhysicsPart(GetOGLVIEW3D(), mViewNr);

        mRelevance = mSelectedByOthers = mStepsShown = 0;
    }

    ~VidolviView()
    {
        ILOG_DEBUG("~Destroying " << mViewNr);
        mPPart->DoDestroyPart();
//        delete mPPart;
//        view3DSys.DeleteView(GetOGLVIEW3D());
    }

    OGLIMAGE *
    UpdateImage(Core::Array::Array2dVec3UInt8 *image)
    {
  //      OGLIMAGE *im = InitOGLIMAGE(image);
  //      view3DSys.SetImage(GetOGLVIEW3D(), im);
//        oglSys.ReleaseOglImage(im);
 //       return im;

/*        if (image == NULL) {
            ILOG_WARN( "NULL image received");
        } else {
            OGLIMAGE *oldOglImage = GetOGLIMAGE();
//            oldOglImage = NULL;
            if (oldOglImage == NULL) {
                ILOG_DEBUG("Creating new OGL Image.");
                OGLIMAGE *im = InitOGLIMAGE(image);
                view3DSys.SetImage(GetOGLVIEW3D(), im);
                oglSys.ReleaseOglImage(oldOglImage);
                oglSys.ReleaseOglImage(im);
                return;
            }
            Core::Array::Array2dVec3UInt8 *oldImage = (Core::Array::Array2dVec3UInt8*) oldOglImage->imageHandle;
            if (oldImage == NULL || (image->CW() != oldImage->CW()) || (image->CH() != oldImage->CH())) {
                ILOG_DEBUG( "Changed resolution from " << oldImage->CW() << "x" << oldImage->CH()<< " to " << image->CW() << "x" << image->CH());
                oldImage = NULL;
                oglSys.ReleaseOglImage(oldOglImage);
                OGLIMAGE *im = InitOGLIMAGE(image);
                view3DSys.SetImage(GetOGLVIEW3D(), im);
                oglSys.ReleaseOglImage(im);

            } else {
                int nBytes = image->CW() * image->CH() * 3;
                memcpy ( oldImage->CPB(0,0), image->CPB(0,0), nBytes);
//                oldOglImage->imageHandle = image;
                oldOglImage->changed = 1;
                oglSys.ReleaseOglImage(oldOglImage);
            }
        } */
    }

    PhysicsPart*
    GetPPart()
    {
        return mPPart;
    }

    int
    GetViewNr()
    {
        return mViewNr;
    }

    void
    SetRelevance(int relevance, int selectedByOthers)
    {
        // 0: unjudged
        // 1: positive
        // 2: negative

        mRelevance = relevance;
        mSelectedByOthers = selectedByOthers;
    }

    void
    SetRelColor()
    {
        float r, g, b, a;
        switch (mRelevance)
        {
            case 0:
                r = g = b = 0.0f; a = 0.5f;
                break;
            case 1:
                r = 0.0f; g = 1.0f; b = 0.0f; a = 0.5f;
                break;
            case 2:
                r = 1.0f; g = 0.0f; b = 0.0f; a = 0.5f;
                break;
        }

        if (mStepsShown < 500)
        {
            float factor = (float)mStepsShown / 500.0f;
            mStepsShown++;
//        r = r * factor;
//        g = g * factor;
//        b = b * factor;
            a = a * factor;
        }

        glColor4f(r,g,b,a);
    }

    // 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);
    }

    virtual void OnDrawView()
    {
        OglGui::View::OnDrawView();

        float w,h,d;
        view3DSys.GetDimensions(GetOGLVIEW3D(), 0, 0, 0, &w, &h, &d);

        glPushMatrix();
        glTranslatef(0.0, 0.0, +0.02f);
        glScalef(w + 0.01,h,d);
        INT         oldBlendInfo[3];
        OGC         oldOGC;
        OGCSave( &oldOGC );
        oglSys.StartBlend( &oldBlendInfo[0] );

//        glColor4f(0.0f, 1.0f, 1.0f, 0.5);
        SetRelColor();
        glBegin(GL_QUADS);
        glVertex3f( -0.5f, -0.5f, -0.02f );
        glVertex3f( +0.5f, -0.5f, -0.02f );
        glVertex3f( +0.5f, +0.5f, +0.02f );
        glVertex3f( -0.5f, +0.5f, +0.02f );
        
        glEnd();
        oglSys.EndBlend( &oldBlendInfo[0] );
        OGCRestore( &oldOGC );
        glPopMatrix();
    }


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

protected:

    OGLIMAGE*
    InitOGLIMAGE(Core::Array::Array2dVec3UInt8* im)
    {
//        ILOG_DEBUG("OGL image created, res = " << im->CW() << "x" << im->CH() << ".");
        mOglIm = oglSys.OglImage(GL_RGB, im->CW(), im->CH());
        mOglIm->imDataFunc = MyOglImdataFunc;
        mOglIm->onDestroy = MyOglImdataDestroyFunc;
  
        mOglIm->noTexScaling = 1;
//        Array2dVec3UInt8* ar = 
//            Core::Array::ArrayCreate<Array2dVec3UInt8>(imW, imH, 0, 0);
        mOglIm->imageHandle = im;
        return mOglIm;

    }

    static void*
    MyOglImdataFunc(OGLIMAGE* oglIm)
    {
        // Obtain our 'im' stored as 'imageHandle'
        Core::Array::Array2dVec3UInt8* ar = (Core::Array::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)
    {
        ILOG_DEBUG("OGL image destroyed.");
        if (!oglIm)
            return;
        Core::Array::Array2dVec3UInt8* ar = (Core::Array::Array2dVec3UInt8 *) oglIm->imageHandle;
        if (ar)
        {
            delete ar;
            ar = 0;
        }
    }

    OGLIMAGE *mOglIm;
    PhysicsPart *mPPart;
    int mViewNr;

    int mRelevance, mSelectedByOthers, mStepsShown;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(VidolviView, Visualization.Application.Videolympics);

}
}
}

#endif

---