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

---

VideoPlayerView.h

Go to the documentation of this file.

#ifndef Impala_Application_SDash_VideoPlayerView_h
#define Impala_Application_SDash_VideoPlayerView_h

#include <vector>
#include <ostream>
#include <strstream>

#include "Link/OGL/OGLWnd.h"
#include "Link/OGL/OGLView2D.h"
#include "Link/OGL/OGLGraphics.h"

#include "Core/Geometry/Rectangle.h"
#include "Core/Array/Arrays.h"
#include "Core/Array/ReadJpg.h"

#include "OglGui/View.h"
#include "OglGui/WindowView2D.h"
#include "OglGui/ViewStrip.h"

#include "Application/sdash/RegionsOfInterestInfo.h"
#include "Application/sdash/RoiLoader.h"

namespace Impala {
namespace Application {
namespace SDash {

class VideoPlayerView : public OglGui::View
{

public:

    typedef Core::Geometry::Rectangle Rectangle;

    // Give constructor extra arguments to pass your information in
    VideoPlayerView(OGLVIEW* oglView) 
        : OglGui::View(oglView), mColor(oglTrGREEN)
    {
        Init();
    }

    virtual ~VideoPlayerView() 
    {
        if (mRoiLoader != 0)
            delete mRoiLoader;
    }

    virtual void OnDrawView()
    {
        // Give possible already existing drawing behavior a chance
        // Example only. Not really necessary in our case
        //OglGui::View::OnDrawView();

        if (mShowFrameNr)
        {
            OGC dbOGC;
            OGCSave(&dbOGC);
            oglSys.PosColPrintf(mView2D->oglWnd, 4,4,oglRED, "fnr: %d", mFrameNr);
            OGCRestore(&dbOGC);
        }

        if (mRegionsOfInterest.empty())
            return;

        //glPushMatrix();
        OGC myOGC;
        OGCSave(&myOGC);

        viewSys.View2DNormTransform(mView2D);

        //SetFillColors(mColor,mColor,mColor,mColor,mColor);
        int bInfo[3];
        oglSys.StartBlend(bInfo);

        SetSolidLineColor(mColor);
        SetLineWidth(3);
        int nrOfRegions = mRegionsOfInterest.size();
        for (int i = 0; i < nrOfRegions; i++)
        {
            const RegionsOfInterestInfo::ScaledRegion& region = mRegionsOfInterest[i];
            DrawRectangle(region.left, region.top, region.width, region.height);
        }

        oglSys.EndBlend(bInfo);

        //viewSys.View2DTransform(mView2D);
        //float x = mX*mView2D->w, y = mY*mView2D->h;
        //oglSys.PosColPrintf(mView2D->oglWnd, x,y,oglRED,
        //                    "sDash", mX, mY); 

        OGCRestore(&myOGC);
        //glPopMatrix();
    }

    // Note: unlike the standard Window::OnMouseFunc the view OnMouse
    // uses float x, float y rather than ints.
    // This to also function for 3D viewers
    virtual void OnMouse(int msg, int btn, int state, float x, float y)
    {
        // Give possible already existing mouse behavior a chance
        // Example only. Not really necessary in our case
        //OglGui::View::OnMouse(msg,btn,state,x,y);

        if (mRegionsOfInterest.empty())
            return;

        // Normalize x,y since this example uses normalized rect coordinates
        float normX = x / mView2D->w;
        float normY = y / mView2D->h;

        int nrOfRegions = mRegionsOfInterest.size();
        for (int i = 0; i < nrOfRegions; i++)
        {
            const RegionsOfInterestInfo::ScaledRegion& region = mRegionsOfInterest[i];
            if (normX >= region.left && normX <= region.left + region.width
                && normY >= region.top && normY <= region.top + region.height)
            {
                mRoiNr = i;

                OGLIMAGE* regionImage = mRoiLoader->Load(mVideoId, mFrameNr, mRoiNr);
                mSubjectWindow->SetImage(regionImage);
                // RvB: OGLIMAGES are refCounted. After mRoiLoader->Load refCount == 1.
                // After mSubjectWindow->SetImage(regionImage); refCount == 2
                // Since the SubjectWindow now has a hold on the image we now must release it
                oglSys.ReleaseOglImage(regionImage);

                // provide the subject image with roi info
                RoiInfo* roiInfo = new RoiInfo();
                roiInfo->videoId = mVideoId;
                roiInfo->frameNr = mFrameNr;
                roiInfo->roiNr = mRoiNr;
                mSubjectWindow->GetOglView()->UserData1 = roiInfo;

                return;
            }
        }

        // no roi clicked; clear the subject window?
    }

    void SubjectWindow(OglGui::WindowView2D* subjectWindow, const std::string& roiPath)
    {
        mSubjectWindow = subjectWindow;
        mRoiLoader = new RoiLoader(roiPath);
    }

    void Color(ULONG col)
    {
        mColor = col;
    }

    int GetVideoId() { return mVideoId; }

    int GetFrameNr() { return mFrameNr; }

    int GetRoiNr() { return mRoiNr; }

    void SetVideoId(int id) { mVideoId = id; }

    void SetFrameNr(int nr) { mFrameNr = nr; }

    void SetRoiNr(int nr) { mRoiNr = nr; }

    void SetRegionsOfInterest(const std::vector<RegionsOfInterestInfo::ScaledRegion>& regions)
    {
        mRegionsOfInterest = regions;
    }

    bool    mShowFrameNr;

private:

    void Init()
    {
        mSubjectWindow = 0;
        mShowFrameNr = true;
        mVideoId = -1;
        mFrameNr = -1;
        mRoiNr = -1;
        mRoiLoader = 0;
    }

    OglGui::WindowView2D*       mSubjectWindow;
    RoiLoader* mRoiLoader;

    ULONG   mColor;
    float   mX, mY, mW, mH;

    int mVideoId;
    int mFrameNr;
    int mRoiNr;
    std::vector<RegionsOfInterestInfo::ScaledRegion> mRegionsOfInterest;

}; //class VideoPlayerView


/*
//  NOTE:   You could also implement VideoPlayerView
//  in a completely different way.
//  If you do not like having the logic in the VideoPlayerView class
//  you could work with an interface class, and implement the interface
//  in a class of your own:
//  This way the intelligence and actions would not be in the View class
//  but at your side.
//  I even think this alternative method is more natural.

    class InspectViewInterface
    {
        virtual void OnDrawView()
        virtual void OnMouse(int camId, float normX, float normY)
        ... Whatever you need
    };

    class SandersClass : public InspectViewInterface
    {
        // Whatever your class has to offer
        // ...

        // Implementation of InspectViewInterface
        virtual void OnDrawView(...)
        {
            // Do your logic
        }
        virtual void OnMouse(int camId, int frameNr, float normX, float normY)
        {
            // Do your logic
        }
        // ... Whatever you need
        // End of InspectViewInterface
    };

    class VideoPlayerView : OglGui::View
    {
    public:
        VideoPlayerView(OGLVIEW* oglView, InspectInterface inspectI) :
            OglGui::View(oglView)
        {
            mInspectI = inspectI;
        }
        virtual void OnDrawView()
        {
            OglGui::View::OnDrawView();
            mInspectI->OnDrawView(...);
        }

        virtual void OnMouse(int msg, int btn, int state, float x, float y)
        {
            OglGui::View::OnMouse(msg,btn,state,x,y);
            float normX = x / mView2D->w;
            float normY = y / mView2D->h;
            mInspectI->OnMouse(mCamId, mFrameNr, normX, normY);
        }

        int mCamId;     // Must be set by the steering class
        int mFrameNr;   // Must be set by the steering class
    };
*/

}
}
}

#endif

---