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

---

RotorBrowserContext.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef Impala_Visualization_RotorBrowser_RotorBrowserContext_h
#define Impala_Visualization_RotorBrowser_RotorBrowserContext_h

#include "RotorViewCache.h"
#include "Core/Trec/Thread.h"
#include "Basis/CmdOptions.h"

namespace Impala {
namespace Visualization {
namespace RotorBrowser {

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

class RotorBrowserContext {
public:
    typedef Core::Trec::Thread                      Thread;

    RotorBrowserContext(RotorViewCache *cache, Thread *thread,
                        int initialposition, double direction=0.0, int depth=4)
    {
        CmdOptions &options = CmdOptions::GetInstance();
        mHighResDistance    = options.GetInt("mdBrowserHighResDistance");

        mContextName        = thread->GetName();
        mContextNiceName    = "";
        mCache              = cache;
        mDirection          = direction;
        mDrawDirection      = DIRECTION_BOTH;
        mDepth              = depth;
        mSwallowMode        = SWALLOW_NONE; 

        mSkip               = NULL;
        mThread             = thread;
        mThread->SetOrigin(mPosition = initialposition);

        if (mPosition == 0)
            GoFirst();
    }

    Thread* GetThread()                 { return mThread; }
    String  GetName()                   { return mContextName; }
    void    SetNiceName(String name)    { mContextNiceName = name; }
    int     GetCenter()                 { return mPosition; }
    bool    GoLeft()                    { return GoRelative(-1); }
    bool    GoRight()                   { return GoRelative(+1); }
    void    GoFirst()                   { mPosition = mThread->GetFirstShot(); }
    bool    PositionExists(int pos)     { return pos >= 0; }
    void    SetSwallowThread(Thread *t) { mSkip = t; }
    void    SetSwallowMode(int mode)    { mSwallowMode = mode; }
    int     GetSwallowMode()            { return mSwallowMode; }
    double  GetDirection()              { return mDirection; }
    void    SetDirection(double dir)    { mDirection = dir; }
    int     GetDepth()                  { return mDepth; }
    void    SetDepth(int depth)         { mDepth = depth; }
    void    SetDrawDirection(int dir)   { mDrawDirection = dir; }
    int     GetDrawDirection()          { return mDrawDirection; }

    bool ThreadValid()
    {
        if (!mCache->ThreadExists(mContextName))
        {
            ILOG_WARN("Thread " << mContextName <<
                      " does not exist, but RotorBrowserContext does.");
            return false;
        }
        mThread = mCache->GetThread(mContextName);
        return true;
    }

    void UpdateViewsToContext(bool showCenter = true)
    {
        if (!ThreadValid())
            return;

        ILOG_DEBUG("UpdateViewsToContext for " << mContextName);
        int start = (mDrawDirection == DIRECTION_UP   ? 0 : -mDepth);
        int stop  = (mDrawDirection == DIRECTION_DOWN ? 0 : mDepth);
        for (int i=start; i<=stop; i++)
        {
            if (i==0 && !showCenter) continue;
            int item = GetRelative(i);
            if (item < 0) continue;
            RotorView *v = mCache->GetViewFor(mContextName, item);

            if (i!=0 && v) // RvB: Added in support of global EnableVideoStills
                v->DisableVideoStills();

            float x,y,z,w,h;
            CalculateCoordinates(x,y,z,w,h,i);
            v->MoveTo(x,y,z,w,h);

            // update probability of shot viewed indexes
            // this depends on the distance to the center, given by i
            if (sAutoNegatives)
            {
                int     absI = abs(i);
                float   prob = absI==0 ? 0.4 : (absI==1 ? 0.1 : 0.04); 
                mCache->ShotIsViewed(item,prob);
                v->SetViewedProbability(mCache->GetViewedProbability(item));
            }
            bool highRes = (i >= -mHighResDistance && i <= mHighResDistance);
            v->SetShowHighResolution(highRes);
        }
    }

    void UpdateViewsToContext(RotorBrowserContext *active)
    {
        if (!ThreadValid())
            return;

        MatchContextTo(active);
        UpdateViewsToContext(false);
    }

    // match centerpoint of this context to that of the other context
    void MatchContextTo(RotorBrowserContext *other)
    {
        int otherCenter = other->GetCenter();
        if (otherCenter != -1)
        {
            mPosition = otherCenter;
            mThread->SetOrigin(mPosition);
        }
    }

    bool GoLast()
    {
        int max   = mThread->GetLength();
        mPosition = mThread->GetShotAt(mThread->GetFirstShot(), max - 1);
        return mPosition >= 0;
    }

    bool GoTo(int position)
    {
        if (position < 0)
            return false;
        mPosition = position;
                return true;
    }

    bool GoRelative(int rpos)
    {
        if (rpos == 0)
            return true;
        int newpos = GetRelative(rpos);
        if (newpos >= 0)
        {
            mPosition = newpos;
            ILOG_DEBUG("GoRelative(" << rpos << " -> " << mPosition << ")");
            return true;
        }
        ILOG_DEBUG("GoRelative(" << rpos << " -> failed)");
        return false;
    }

    bool MoveRelative(int rpos)
    {
        if (rpos < 0)
            for (int i=0; i < -rpos; i++) GoLeft();
        else
            for (int i=0; i < rpos; i++)  GoRight();

        ILOG_DEBUG("MoveRelative(" << rpos << " -> " << GetRelative(0) << ")");
        return true;
    }

    bool ShouldRelPosSwallow(int rpos)
    {
        if (!RotorBrowserContext::sGlobalShotSwallow || !mSkip)
            return false;
        return (rpos < 0 && (mSwallowMode & SWALLOW_NEGATIVE)) ||
               (rpos > 0 && (mSwallowMode & SWALLOW_POSITIVE));
    }

    int GetRelative(int rpos)
    {
        // RvB: Added to prevent crash on key 'b' when no bookmarks exist
        if (mPosition<0) return -1;
        int newpos;
        if (ShouldRelPosSwallow(rpos))
            newpos = mThread->GetShotAtWhileSkipping(mPosition, rpos, mSkip);
        else
            newpos = mThread->GetShotAt(mPosition, rpos);
        return PositionExists(newpos) ? newpos : -1;
    }

    // returns true iff position is currently shown on screen
    bool ShowsPosition(int position)
    {
        for (int i = -mDepth; i <= mDepth; i++)
            if (GetRelative(i) == position)
                return true;
        return false;
    }

        String GetNiceName()
        {
        if (mContextNiceName != "")
            return mContextNiceName;
                if (mContextName.find("rank_thread_") != String::npos)
                        return String("R: conceptual ") + mContextName.substr(12);
                if (mContextName.find("rank_") != String::npos)
                        return String("R: ") + mContextName.substr(5);
                if (mContextName.find("shots_initialquery") != String::npos)
                        return String("initial query");
                if (mContextName.find("shots_vis_") != String::npos)
                        return String("R: visual for ") + mContextName.substr(10);
                if (mContextName.find("shots_textual:") != String::npos)
                        return String("T: ") + mContextName.substr(14);
                if (mContextName.find("shots_") != String::npos)
                        return String("S: ") + mContextName.substr(6);

                return mContextName;
        }

    static void SetGlobalShotSwallow(bool swallow)
    {
        RotorBrowserContext::sGlobalShotSwallow = swallow;
    }
    static bool GetGlobalShotSwallow()
    {
        return RotorBrowserContext::sGlobalShotSwallow;
    }
    static bool GetAutoNegatives()
    {
        return RotorBrowserContext::sAutoNegatives;
    }
    static void SetAutoNegatives(bool val)
    {
        RotorBrowserContext::sAutoNegatives = val;
    }

private:
    void CalculateCoordinates(float& x, float& y, float& z,
                              float& w, float& h, int depth)
    {
        float dist;
        switch (abs(depth)) {
            case 0:  dist = 0.0f;  w = 1.8f; break;
            case 1:  dist = 0.44f; w = 1.3f; break;
            default: dist = 0.56f; w = 1.0f; break;
        }
        if (depth < 0) dist = -dist;

        float xInc = cos(mDirection);
        float yInc = sin(mDirection);
        float fact = 1.1f;
        x = xInc * fact * depth + dist * xInc;
        y = yInc * fact * depth + dist * yInc;
        z = -10.0f + degrade(depth/6.0)*3.0;

        h = 1.0f;
        if (depth >=2)  h -= 0.2 *  (depth-2);
        if (depth <=-2) h -= 0.2 * -(depth+2);
        if (h < 0) h  = 0;
    }

    inline double degrade(double x)
    {
        return 1.0 - x * x;
    }

    /* RvB: Not used
    inline double N(double x)
    {
        return (1.0/sqrt(2.0*M_PI))*exp(-0.5*x*x);
    }
    */

    RotorViewCache*         mCache;
    Thread*                 mThread;
    Thread*                 mSkip;
    String                  mContextName;
    String                  mContextNiceName;

    int                     mPosition;
    int                     mDepth;
    int                     mSwallowMode;
    int                     mHighResDistance;
    int                     mDrawDirection;

    double                  mDirection;

    static bool             sGlobalShotSwallow;
    static bool             sAutoNegatives;

public:
    static const int        SWALLOW_NONE     = 0;
    static const int        SWALLOW_POSITIVE = 1;
    static const int        SWALLOW_NEGATIVE = 2;
    static const int        SWALLOW_ALL      = 3;


    static const int        DIRECTION_BOTH   = 0;
    static const int        DIRECTION_UP     = 1;
    static const int        DIRECTION_DOWN   = 2;

    // up = right and down = left, for consistency.
    static const int        DIRECTION_LEFT   = 2;
    static const int        DIRECTION_RIGHT  = 1;

    ILOG_VAR_DEC;

}; // class RotorBrowserContext

ILOG_VAR_INIT(RotorBrowserContext, Visualization.RotorBrowser);

bool RotorBrowserContext::sAutoNegatives        = false;
bool RotorBrowserContext::sGlobalShotSwallow    = false;

}
}
}
#endif

---