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

---

RotorView.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef Impala_Visualization_RotorBrowser_RotorView_h
#define Impala_Visualization_RotorBrowser_RotorView_h

#include "Core/Trec/ThreadSet.h"
#include "Basis/CmdOptions.h"
#include "Core/ImageSet/ImageSet.h"
#include "Core/VideoSet/Stills.h"
#include "Core/Array/Arrays.h"
#include "Core/Geometry/Rectangle.h"

#include "Visualization/RgbOglImage.h"
#include "RotorDoDView.h"
#include "RotorViewCacheResolver.h"

namespace Impala {
namespace Visualization {
namespace RotorBrowser {

//using namespace OglGui;
//using namespace Impala::Core::Trec;

class RotorViewListener
{
public:
    virtual void
    OnRectangleSelect(int shotID, float x, float y, float w, float h)
    {
    }
};

class RotorView : public RectangleListener
{
public:
    typedef Core::Trec::Thread              Thread;
    typedef Core::Trec::ThreadSet           ThreadSet;
    typedef Core::Array::Array2dVec3UInt8   Array2dVec3UInt8;
    typedef Core::ImageSet::ImageSet        CoreImageSet;
    typedef Core::Stream::RgbDataSrc        RgbDataSrc;
    typedef Core::Geometry::Rectangle       GeoRectangle;

//    RotorView(Window *browser, ThreadSet *threadset, CString name,
//              int nr, float x, float y, RotorViewCacheResolver* resolver=NULL)
    RotorView(OglGui::Window *browser, ThreadSet *threadset, CString name,
              int nr, float x, float y, RotorViewCacheResolver* resolver=NULL)
    {
        mViewListener           = NULL;
        mNr                     = nr;
        mName                   = name;
        mThreadSet              = threadset;
        mTurnsNotShown          = 0;
        mDeleteThreshold        = 5;
        mIsBookmarked           = false;
        mIsBookmarkedNegative   = false;
        mUseKeyframes           = RotorView::KEYFRAMES_NEVER;
        mAspectRatio            = 1.375f;
        mIsHighRes              = false;
        mCurrentRes             = false;
        mIsShowingStills        = false;
        mStillImages            = NULL;
        mVideoSource            = NULL;
        mPlayUntilEnd           = false;
        mViewBeingRecycled      = false;
        mViewedProbability      = 0.0;
        mBookmarked             = GetThreadByName("bookmarked");
        mBookmarkedNegative     = GetThreadByName("bookmarked_negative");
        mRect                   = GeoRectangle(10, 10, 50, 20);
        mTimer                  = new Timer(1);
        mLastTime               = mTimer->SplitTime();
        CmdOptions &options     = CmdOptions::GetInstance();
        mUseKeyframes           = options.GetInt("mdBrowserUseKeyframes");

        if (mUseKeyframes == KEYFRAMES_ALWAYS)
            mCurrentRes = mIsHighRes = true;

        mAspectRatio = (float)options.GetDouble("mdBrowserAspectRatio");
        mForceAspect = mAspectRatio > 0.0 ? true : false;

        RegisterView(browser, x, y, resolver);
        UpdateBookmarkState();
    }

    ~RotorView()
    {
        if (!mViewBeingRecycled)
            delete mView;

        if (mVideoSource)
            delete mVideoSource;
    }

    void SetViewListener(RotorViewListener *t)
    {
        mViewListener = t;
    }

    Thread* GetThreadByName(CString name)
    {
        return mThreadSet->GetThreadByName(name);
    }

    inline String GetName() { return mName; }
    inline int    GetNR()   { return mNr; }
    inline float  GetX()    { return mReqX; }
    inline float  GetY()    { return mReqY; }
    inline float  GetZ()    { return mReqZ; }
    inline float  GetRX()   { return mReqW; }
    inline float  GetRY()   { return mReqH; }
    
    void Rename(CString newname)        { mName = newname; }
    void SetViewedProbability(float f)  { mViewedProbability = f; }
    void SetPlayUntilEnd(bool v)        { mPlayUntilEnd = v; }
    void Hide()                         { mIsShown = false; }
    bool IsCurrentlyShown()             { return mIsShown; }
    bool GetPlayUntilEnd()              { return mPlayUntilEnd; }
    bool GetVideoStillsEnabled()        { return mVideoSource != 0; }

    /* should be called from RotorBrowser::DisplayFunc */
    bool DrawView()
    {
        if (!mIsShown) return false;

        mView->SetVisible(true);
        if (mIsShowingStills)
            UpdateStill();

        bool stillRequiresMovement = DoPhysics();

        OGLVIEW3D *oglV3D = mView->GetOGLVIEW3D();
        if (oglV3D->object3D && oglV3D->im)
        {
            OGLIMAGE* im = oglV3D->im;
            CheckOglImageChanged(im);
            // Scale to view dims
            float tW = im->noTexScaling ? im->texW : im->w;
            float tH = im->noTexScaling ? im->texH : im->h;
            float zX = (oglV3D->w)*(tW/im->w);
            float zY = (oglV3D->h)*(tH/im->h);
            view3DSys.SetZoom(oglV3D,zX,zY);

            float f = (oglV3D->x == 0 || oglV3D->y == 0) ? 0.15 : 0.08;
            float opacity = fabs(oglV3D->x * f) + fabs(oglV3D->y * f);
            opacity = opacity > 0.8 ? 0.8 : opacity;
            mView->SetObscure(opacity);

            float a = sShowPositiveBookmarks&&mIsBookmarked ? 0.2 : 0;
            mView->PositiveAlpha(a);
            a = sShowNegativeBookmarks&&mIsBookmarkedNegative ? 0.2 : 0;
            mView->NegativeAlpha(a);
            mView->ProbabiltyAlpha(0);
            if (sShowProbabilityFeedback && mViewedProbability > 0)
                mView->ProbabiltyAlpha(mViewedProbability);
        }
        view3DSys.DrawView(oglV3D);
        return stillRequiresMovement | mIsShowingStills;
    }


    void MoveTo(float x, float y, float z, float resX =0.0f, float resY = 0.0f)
    {
        mReqX = x; mReqY = y; mReqZ = z;
        mReqW = resX; mReqH = resY;
    }

    void MoveFrom(float x, float y, float z, float resX, float resY)
    {
        if (!mMoveNow)
            return;
        mActX = x; mActY = y; mActZ = z;
        mActW = resX; mActH = resY;
        mMoveNow = false;
    }

    void MoveNOW()
    {
        mActX = mReqX; mActY = mReqY; mActZ = mReqZ;
        mActW = mReqW; mActH = mReqH;
    }

    void SetRect(GeoRectangle r)
    {
        mRect = r;
        mRect.CheckSize();
    }

    GeoRectangle GetRect()
    {
        return mRect;
    }

    void SetShowHighResolution(bool showhighresolution)
    {
        if (mUseKeyframes == RotorView::KEYFRAMES_ALWAYS)
            return;
        mIsHighRes = showhighresolution;
        UpdateResolution();
    }

    bool GetShowHighResolution()
    {
        return mIsHighRes;
    }

    void
    SetShowStills(Core::VideoSet::Stills *stills, CoreImageSet* stillImages)
    {
        mIsShowingStills = true;
        if (mStillImages != NULL)
            return;

        mStillStart  = stills->GetFirstStillShot(mNr);
        mStillEnd    = mStillStart + stills->GetNrStillsShot(mNr);
        mStillPos    = mStillStart;
        mStillImages = stillImages;
    }

    void DisableVideoStills()
    {
        if (mVideoSource != NULL)
        {
            delete mVideoSource;
            mVideoSource = NULL;
        }
    }

    bool EnableVideoStills(Core::VideoSet::SegmentationDocument* doc)
    {
        if (mVideoSource != NULL)
            return true;

        int shot = doc->CurShot();
        int vidId = doc->CurFileId();
        Core::VideoSet::Segmentation* shots = doc->GetSegmentation();
        ILOG_DEBUG("RotorView::EnableVideoStills: initializing video stream..");
        mVideoSource = doc->GetVideoSet()->GetVideo(vidId);
        if (!mVideoSource)
            return false;

// RvB: Added to prevent crashes
#ifdef AS_TODS_BROWSER
        if (!mVideoSource->HasIndex())
        {
            ILOG_WARNING("Video [" << vidId << "] has no index: Not playing");
            DisableVideoStills();
            return false;
        }
#endif
        mVideoStart = shots->GetStart(shot) + 1;
        mVideoEnd = shots->GetEnd(shot);

        mVideoSource->GotoFrame(mVideoStart);
        ILOG_DEBUG( "RotorView::EnableVideoStills: video stream ready." );

        return true;
    }
    void SetHideStills()
    {
        mIsShowingStills = false;
        // to revert to representative keyframe, enable next line:
        // DoUpdateCurrentImage();
    }

    void UpdateBookmarkState()
    {
        if (mBookmarked)
            mIsBookmarked = mBookmarked->GetShotPosition(mNr) != -1;
        if (mBookmarkedNegative)
            mIsBookmarkedNegative=mBookmarkedNegative->GetShotPosition(mNr)!=-1;
    }

    bool IsInvalid()
    {
        if (mViewBeingRecycled)
        {
            ILOG_WARN( "RotorView::IsInvalid: yes. View is being recycled!" );
            return true;
        }
        return !mIsShown && mTurnsNotShown > mDeleteThreshold;
    }

    void Show()
    {
        if (mViewBeingRecycled)
        {
            ILOG_WARN("RotorView::Show: view is being recycled! Can't show!" );
            return;
        }
        mIsShown = true;
        if (mTurnsNotShown > 2)
            mMoveNow = true;
        mTurnsNotShown = 0;
    }

        void TryDelete()
    {
        mTurnsNotShown++;
        if (IsInvalid())
            delete this;
    }

        bool IsUnused()
    {
        mTurnsNotShown++;
        return IsInvalid();
    }

    RotorDoDView* RecycleView()
    {
        mIsShown = false;
        mViewBeingRecycled = true;
        mViewedProbability = 0.0;
        view3DSys.SetUserData(mView->GetOGLVIEW3D(), VIEW_ROTORVIEW, NULL);
        return mView;
    }

    bool IsSameAs(CString name, int nr)
    {
        return (mNr == nr && mName == name);
    }

    // handlers:
    virtual void
    OnRectangleSelect(float x, float y, float w, float h)
    {
        if (mViewListener)
            mViewListener->OnRectangleSelect(mNr, x, y, w, h);
    }

    static void SetStillFrameWait(int fw) {
        RotorView::sStillFrameWait = fw;
    }
    static int GetStillFrameWait() {
        return RotorView::sStillFrameWait;
    }

    static void SetShowPositiveBookmarks(bool val) {
        sShowPositiveBookmarks = val;
    }
    static bool GetShowPositiveBookmarks()
    {
        return sShowPositiveBookmarks;
    }

    static void SetShowNegativeBookmarks(bool val) {
        sShowNegativeBookmarks = val;
    }
    static bool GetShowNegativeBookmarks() {
        return sShowNegativeBookmarks;
    }

    static void SetShowProbabilityFeedback(bool val) {
        sShowProbabilityFeedback = val;
    }
    static bool GetShowProbabilityFeedback() {
        return sShowProbabilityFeedback;
    }

    static void SetSpeedFactor(float f)
    {
        if (f > 1.0 && f < 20.0)
            RotorView::sFactor = f;
        if (f <= 1.0)
            RotorView::sFactor = 1.0;
    }
    static float GetSpeedFactor()
    {
        return RotorView::sFactor;
    }

private:

    void UpdateResolution()
    {
        if (mUseKeyframes == KEYFRAMES_CENTER && mIsHighRes != mCurrentRes)
        {
            // returning to low resolution would be silly;
            if (!mIsHighRes) return;

            ILOG_DEBUG("Switching to keyframe image for "<< mName << ":"<<mNr);
            DoUpdateCurrentImage();
        }
    }

    // RvB: Placed in its own function to prevent double coding
    // Exact copies were coded inside:
    //      DoUpdateCurrentImage, UpdateStill, RegisterView
    void UpdateWithImage(Array2dVec3UInt8* image)
    {
        if (image == NULL)
        {
            ILOG_WARN( "NULL image received for shot ID " << mNr );
            return;
        }

        OGLIMAGE* oldOglIm = mView->GetOGLIMAGE();
        Array2dVec3UInt8* oldIm = (Array2dVec3UInt8*) oldOglIm->imageHandle;

        // RvB: The new image only has to have smaller dims then texture
        //if ((image->CW() != oldIm->CW()) || (image->CH() != oldIm->CH()))
        if ((image->CW() > oldOglIm->texW) || (image->CH() > oldOglIm->texH))
        {
            ILOG_DEBUG( "Changed resolution from "
                        << oldIm->CW() << "x" << oldIm->CH()
                        << " to " << image->CW() << "x" << image->CH());
            OGLIMAGE *im = InitOGLIMAGE(image);
            mView->SetImage(im);
            oglSys.ReleaseOglImage(im);
        }
        else
        {
            delete oldIm;
            oldOglIm->imageHandle = image;
            oldOglIm->w = image->CW();
            oldOglIm->h = image->CH();
            oldOglIm->changed = 1;
        }
        oglSys.ReleaseOglImage(oldOglIm);
    }

    void DoUpdateCurrentImage()
    {
        Array2dVec3UInt8* image = mThreadSet->GetImageByShotID(mNr,mIsHighRes);
        UpdateWithImage(image);
        mCurrentRes = mIsHighRes;
    }

    bool HasNextStill()
    {
        double cpuTime = mTimer->SplitTime();
        double frTime  = mVideoSource ? 0.04 : RotorView::sStillFrameWait*0.01;
        if (cpuTime-mLastTime >= frTime)
        {
            mLastTime = cpuTime;
            return true;
        }
        return false;
    }

    Array2dVec3UInt8* getNextStill()
    {
        if (mVideoSource != NULL)
        {
            RgbDataSrc* src = mVideoSource;
            if (src->TheEnd())
                src->GotoFrame(mVideoStart);
            else if (!mPlayUntilEnd && src->FrameNr() > mVideoEnd)
                src->GotoFrame(mVideoStart);
            else
                src->NextFrame();
            return Core::Array::ArrayCreate<Array2dVec3UInt8>
              (src->FrameWidth(),src->FrameHeight(),0,0,src->DataPtr(),true);
        }

        if ((mStillPos += 1) >= mStillEnd)
            mStillPos = mStillStart;
        return mStillImages->GetImage(mStillPos);
    }

    // RvB: Changed to use UpdateWithImage
    void UpdateStill()
    {
        if (!HasNextStill()) return;

        Array2dVec3UInt8* image = getNextStill();
        UpdateWithImage(image);
    }

    void
    //RegisterView(Window *b, float x, float y, RotorViewCacheResolver* resolver)
    RegisterView(OglGui::Window *b, float x, float y, RotorViewCacheResolver* resolver)
    {
        mBrowser    = b;
        mCurrentRes = mIsHighRes;

        Array2dVec3UInt8* image = mThreadSet->GetImageByShotID(mNr,mIsHighRes);
        OGLWND*           oglWnd = b->GetOGLWND();
        if (image == NULL)
        {
            ILOG_WARN("NULL image received for shot ID " << mNr);
            mView = new RotorDoDView(oglWnd,NULL,x,y,-10.0f,1.0f,1.0f,1.0f);
        }
        else
        {
            int imW = image->CW(), imH = image->CH();
            if (!mForceAspect)
                mAspectRatio = imH==0 ? 1.f : imW/(float)imH;
            if (resolver) // recycle old RotorDoDView for new purposes.
            {                
                // This is fastest when old view had the same texture size.
                if (!(mView = resolver->FindRecycledView(imW, imH)))
                    ILOG_ERROR("RegisterView:resolver should not return NULL!");
                UpdateWithImage(image);
            }
            else // nothing to recycle: create a new view
            {   
                OGLIMAGE *im = InitOGLIMAGE(image);
                mView = new RotorDoDView(oglWnd,im,x,y,-100.0f,1.0f,1.0f,1.0f);
                oglSys.ReleaseOglImage(im);
            }
        }

        view3DSys.SetUserData(mView->GetOGLVIEW3D(), VIEW_ROTORVIEW, this);

         // map rectangle select to this RotorView now.
        mView->SetCurrentRotorView(this);

        mActX = mReqX = x;
        mActY = mReqY = y;
        mActZ = mReqZ = -10.0f;

        mActW = mActH = mReqW = mReqH = 0.0f;
        mMoveNow = true;
    }

/*
    void removeView()
    {
        // destroy the RotorDoDView only when it's not being recycled:
        if (!mViewBeingRecycled) {
            delete mView;
        }
    }
*/

protected:
    OGLIMAGE* InitOGLIMAGE(Array2dVec3UInt8* im)
    {
        OGLIMAGE* oglIm = RgbOglImage::OglImage(im);
        oglIm->noTexScaling = 1;
        oglIm->changed = 1;
        return oglIm;
    }

private:
    bool DoPhysics()
    {
        mView->GetDimensions3D(&mActX,&mActY,&mActZ,NULL,NULL,NULL);

        if (mMoveNow)
        {
            mActX = mReqX; mActY = mReqY; mActZ = mReqZ;
            mActW = mReqW; mActH = mReqH;
            mMoveNow = false;
        }
        else
        {
            mActX += (mReqX - mActX) / sFactor;
            mActY += (mReqY - mActY) / sFactor;
            mActZ += (mReqZ - mActZ) / sFactor;
            mActW += (mReqW - mActW) / sFactor;
            mActH += (mReqH - mActH) / sFactor;
        }
        float vW = mAspectRatio >  1.0 ? mActW*mAspectRatio : mActW;
        float vH = mAspectRatio <= 1.0 ? mActW/mAspectRatio : mActW;
        mView->SetDimensions3D(mActX,mActY,mActZ,vW,vH,FRETAIN);

        return AlmostAtDestiny() ? false : true;
    }

    bool AlmostAtDestiny()
    {
        return IsAlmost(mActX, mReqX) &&
               IsAlmost(mActY, mReqY) &&
               IsAlmost(mActZ, mReqZ) &&
               IsAlmost(mActW, mReqW) &&
               IsAlmost(mActH, mReqH);
    }

    bool IsAlmost(float a, float r)
    {
        return (a==r) || (a>r && a - r < 0.01) || (r>a && r - a < 0.01);
    }

    //Window*                 mBrowser;
    OglGui::Window*         mBrowser;
    RotorDoDView*           mView;
    RotorViewListener*      mViewListener;

    ThreadSet*              mThreadSet;
    Thread*                 mBookmarked;
    Thread*                 mBookmarkedNegative;

    GeoRectangle            mRect;

    CoreImageSet*           mStillImages;
    RgbDataSrc*             mVideoSource;

    String                  mName;

    Timer*                  mTimer;
    double                  mLastTime;

    int                     mNr;
    int                     mTurnsNotShown;
    int                     mDeleteThreshold;
    int                     mUseKeyframes;

    int                     mVideoStart, mVideoEnd;
    int                     mStillStart, mStillEnd;
    int                     mStillPos;

    float                   mActX, mActY, mActZ, mActW, mActH; // actual XYZWH
    float                   mReqX, mReqY, mReqZ, mReqW, mReqH; // requested
    float                   mAspectRatio;
    float                   mViewedProbability;

    bool                    mIsShown;
    bool                    mMoveNow;
    bool                    mIsBookmarked;
    bool                    mIsBookmarkedNegative;
    bool                    mForceAspect;
    bool                    mIsHighRes;
    bool                    mCurrentRes;
    bool                    mViewBeingRecycled;
    bool                    mPlayUntilEnd;
    bool                    mIsShowingStills;

    static float            sFactor;
    static int              sStillFrameWait;
    static bool             sShowNegativeBookmarks;
    static bool             sShowPositiveBookmarks;
    static bool             sShowProbabilityFeedback;

public:
    static const int        KEYFRAMES_NEVER  = 0;
    static const int        KEYFRAMES_CENTER = 1;
    static const int        KEYFRAMES_ALWAYS = 2;
    static const int        VIEW_ROTORVIEW   = 4;
 
   ILOG_VAR_DEC;

}; // class RotorView

ILOG_VAR_INIT(RotorView, Visualization.RotorBrowser);

float   RotorView::sFactor                  = 1.0;
int     RotorView::sStillFrameWait          = 15;

bool    RotorView::sShowNegativeBookmarks   = true;
bool    RotorView::sShowPositiveBookmarks   = true;
bool    RotorView::sShowProbabilityFeedback = false;
}
}
}
#endif

---