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

---

ThreadClusterSelector.h

Go to the documentation of this file.

#ifndef Impala_Visualization_RotorBrowser_ThreadClusterSelector_h
#define Impala_Visualization_RotorBrowser_ThreadClusterSelector_h

#include "OglGui/Window.h"
#include "Visualization/KeyBindingsMap.h"
#include "RotorView.h"
#include "RotorViewCache.h"
#include "RotorBrowserContext.h"

#include "Core/Trec/ThreadSet.h"

#include <vector>


namespace Impala {
namespace Visualization {
namespace RotorBrowser {

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

class ThreadClusterSelector
{
public:
    typedef Core::Trec::Thread                      Thread;
    typedef Core::Trec::ThreadShots                 ThreadShots;
    typedef Core::Trec::ThreadRank                  ThreadRank;
    typedef Core::Trec::ThreadVisualSimilarity      ThreadVisualSimilarity;

    ThreadClusterSelector(RotorViewCache *cache)
    {
        InitKeyBindings();
        mCache              = cache;
        mShowing            = false;
        mSelectionSize      = 36;
        mPaginated          = true;

        mThresholdDelta     = 0.2;
        mThresholdDissim    = true;
    }

    bool CheckKBN(String keyStr, int c, int state, int n=6)
    {
        return CheckKeyBindingExt(mKeyBindings, keyStr, c, state, n);
    }

    void InitKeyBindings()
    {
        KeyBindingsMap& kb = mKeyBindings;

        InitKeyBinding(kb,"RbCsNextPage",                  "d", "D");    
        InitKeyBinding(kb,"RbCsPrevPage",                  "a", "A");
        InitKeyBinding(kb,"RbCsIncrSelectionSize",         "w", "W");
        InitKeyBinding(kb,"RbCsDecrSelectionSize",         "s", "S");
        InitKeyBinding(kb,"RbCsBrowseDecrSelectionSize",   "a", "A");
        InitKeyBinding(kb,"RbCsBrowseIncrSelectionSize",   "d", "D");
        InitKeyBinding(kb,"RbCsTogglePaginate",            "r", "R");
        InitKeyBinding(kb,"RbCsClusterBookPositive",       "space");
        InitKeyBinding(kb,"RbCsClusterBookPositiveForced", "shift-space");
        InitKeyBinding(kb,"RbCsClusterBookNegative",       "x");
        InitKeyBinding(kb,"RbCsClusterBookNegativeForced", "X");
    }

    void Show(RotorBrowserContext *context)
    {
        mContext = context;
        mShowing = true;
        ILOG_DEBUG("Showing thread cluster selector");
        mThresholdDelta = GetThresholdForNumber(6);
        ShowRelevantSquare();
    }

    void Hide()
    {
        mShowing = false;
    }

    bool IsActive()
    {
        return mShowing;
    }

    int GetSelectionSize()
    {
        if (!mPaginated)
            return GetNumberForThreshold();
        return mSelectionSize;
    }

    void SetSelectionSize(int nr)
    {
        if (!mPaginated)
            return;

        if (nr < 1)
            nr = 1;
        if (nr > 96)
            nr = 96;
        mSelectionSize = nr;
        ShowRelevantSquare();
    }


    int GetPageSize(int n)
    {
        if (n > 96) return 13;
        if (n > 88) return 12;
        if (n > 80) return 11;
        if (n > 72) return 10;
        if (n > 64) return 9;
        if (n > 49) return 8;
        if (n > 36) return 7;
        if (n > 25) return 6;
        if (n > 16) return 5;
        if (n > 9) return 4;
        if (n > 4) return 3;
        if (n > 1) return 2;
        if (n== 1) return 1;
        return 0;
    }

    int GetNumberOnPage(int n)
    {
        if (n < 0) n = 0;
        if (n > 11) n = 11;
        switch (n)
        {
            case 1: return 1;
            case 2: return 4;
            case 3: return 9;
            case 4: return 16;
            case 5: return 25;
            case 6: return 36;
            case 7: return 49;
            case 8: return 64;
            case 9: return 72;
            case 10: return 80;
            case 11: return 88;
            case 12: return 96;
        }
        // RvB: Added to stop compiler from complaining (n==12 never reached!)
        return n;
    }

    Real64 GetThresholdForShotId(int shot)
    {
        // some semi-evil calling to convert shot into quid, into position,
        // into similarity... This ought to be optimized.
        Thread *t = mContext->GetThread();
        int position = t->GetShotPosition(shot);
        if (t >= 0)
        {
            if (t->GetType() == Thread::SHOTS)
                return ((ThreadShots*)t)->GetShotScore(position);
            if (t->GetType() == Thread::RANK)
                return ((ThreadRank*)t)->GetShotScore(position);
            if (t->GetType() == Thread::VISUAL)
                return ((ThreadVisualSimilarity*)t)->GetSimilarity(shot);
        }
        else
        {
            ILOG_WARN("Could not find position for shot " << shot <<
                      " in thread " << mContext->GetName());
            return 1.0;
        }
        // RvB: Added as compiler complained: no return
        return 1.0;
    }

    Real64 GetTDelta(Real64 a, Real64 b)
    {
        if (b > a)
            return b - a;
        return a - b;
    }

    int GetNumberForThreshold()
    {
        bool goodShot = true;
        double thisShotSim = GetThresholdForShotId( GetRelevant(0) );
        ILOG_DEBUG("Base thres=" << thisShotSim);
        int ctr = 1;
        while (true)
        {
            double nextShotSim = GetThresholdForShotId( GetRelevant(ctr) );

            if (GetTDelta(thisShotSim, nextShotSim) > mThresholdDelta)
            {
                ILOG_DEBUG(" pos " << ctr << " shot " << GetRelevant(ctr) <<
                           " score " << nextShotSim);
                break;
            }
            if (ctr < 10)
                ILOG_DEBUG(" pos " << ctr << " shot " << GetRelevant(ctr) <<
                           " score " << nextShotSim);
            ctr ++;

            if (ctr >= 96)
                break;
        }
        ILOG_DEBUG("number of relevant images: " << ctr);
        return ctr;
    }

    Real64 GetThresholdForNumber(int number)
    {

        Real64 thisShotSim = GetThresholdForShotId( GetRelevant(0) );
        ILOG_DEBUG("GetThresholdForNumber start thres=" << thisShotSim);
        Real64 thatShotSim = GetThresholdForShotId( GetRelevant(number) );
        ILOG_DEBUG("GetThresholdForNumber stop " << number << " thres=" <<
                   thatShotSim);

        Real64 tdelta = GetTDelta(thatShotSim, thisShotSim);
//        ILOG_DEBUG("Threshold for " << number << " images: " << tdelta);
        tdelta += 0.05 * tdelta;

        ILOG_DEBUG("Threshold for " << number << " images: " << tdelta);
        return tdelta;
    }

    /*
     currently rewriting all Threads to have similarity, this is a safety net
     so we can work with similarity / non-similarity threads at the same time.
    */
    bool CurrentContextHasSimilarities()
    {
        return  mContext && mContext->GetThread() &&
                (mContext->GetThread()->GetType() == Thread::RANK ||
                mContext->GetThread()->GetType() == Thread::SHOTS ||
                mContext->GetThread()->GetType() == Thread::VISUAL);
    }

    void DecreaseThreshold()
    {
        int number = GetNumberForThreshold();
        number = number / 2;
        mThresholdDelta = GetThresholdForNumber(number);

        if (mThresholdDelta < 0.001) mThresholdDelta = 0.001;
        ILOG_DEBUG("Threshold at " << mThresholdDelta);
    }

    void IncreaseThreshold()
    {
        int number = GetNumberForThreshold();
        mThresholdDelta = GetThresholdForNumber(number + 1);
        
        //if (mThresholdDelta > 1.0) mThresholdDelta = 1.0;
        ILOG_DEBUG("Threshold at " << mThresholdDelta);
    }

    void IncreaseSelectionSize()
    {
        if (mPaginated)
            SetSelectionSize(GetNumberOnPage(GetPageSize(mSelectionSize)+1));
        else
        {
            IncreaseThreshold();
            SetSelectionSize(GetNumberForThreshold());
        }
        ShowRelevantSquare();
    }

    void DecreaseSelectionSize()
    {
        if (mPaginated)
            SetSelectionSize(GetNumberOnPage(GetPageSize(mSelectionSize)-1));
        else
        {
            DecreaseThreshold();
            SetSelectionSize(GetNumberForThreshold());
        }
        ShowRelevantSquare();
    }

    bool GetPagemode()
    {
        return mPaginated;
    }

    /* SetPagemode(mode)
        false: paginated browsing
        true: threshold based browsing
    */
    void SetPagemode(bool pagemode)
    {
        if (pagemode == false && !CurrentContextHasSimilarities())
        {
            ILOG_WARN("Could not switch to threshold mode, " << 
                      "active thread does not have similarities.");
            return;
        }
        mPaginated = pagemode;
        ShowRelevantSquare();
    }

    // use GetSelectedShotsCount and GetSelectedShots for
    // batch ops on all visible and selected shots, instead
    // of assuming all visible shots in square.
    int GetSelectedShotsCount()
    {
        if (!mPaginated)
            return GetNumberForThreshold();
        return mSelectionSize;
    }

    std::vector<int> GetSelectedShots()
    {
        std::vector<int> shots;
        for (int i=0; i<GetSelectedShotsCount(); i++)
            shots.push_back(GetRelevant(i));

        return shots;
    }

    // use GetVisibleShotsCount and GetVisibleShots for
    // batch ops on all visible shots.
    int GetVisibleShotsCount()
    {
        if (!mPaginated)
            return GetNumberForThreshold();
        return mSelectionSize;
    }

    std::vector<int> GetVisibleShots()
    {
        std::vector<int> shots;
        for (int i=0; i<GetVisibleShotsCount(); i++)
            shots.push_back(GetRelevant(i));

        return shots;
    }

    bool ClusterKeyboardFunc(int c, int state)
    {
        bool keyHandled = true;

        if (!GetPagemode())
        {
            // when browsing clusters do not allow page flips, but
            // change cluster size instead.
            //if (c == 'a' || c == 'A') c = 's';
            //if (c == 'd' || c == 'D') c = 'w';
            if (CheckKBN("RbCsBrowseDecrSelectionSize", c, state))
                c = 's';
            if (CheckKBN("RbCsBrowseIncrSelectionSize", c, state))
                c = 'w';
        }

        if (CheckKBN("RbCsDecrSelectionSize", c, state))
            c = 's';
        else if (CheckKBN("RbCsIncrSelectionSize", c, state))
            c = 'w';
        else if (CheckKBN("RbCsNextPage", c, state))
            c = 'd';
        else if (CheckKBN("RbCsPrevPage", c, state))
            c = 'a';
        else if (CheckKBN("RbCsTogglePaginate", c, state))
            c = 'r';

        switch (c)
        {
            case 's': // S(maller)
                ILOG_USER("KB: decrease selection size in cluster viewer");
                DecreaseSelectionSize();
                break;
            case 'w': // W(ider)
                ILOG_USER("KB: decrease selection size in cluster viewer");
                IncreaseSelectionSize();
                break;

            case 'd':
                ILOG_USER("KB: move to next page in cluster viewer");
                mContext->MoveRelative(GetSelectionSize());
                Show(mContext);
                break;

            case 'a':
                ILOG_USER("KB: move to previous page in cluster viewer");
                mContext->MoveRelative(-GetSelectionSize());
                Show(mContext);
                break;

            case 'r':
                ILOG_USER("KB: Toggle paginate / threshold mode");
                SetPagemode(!GetPagemode());
                ILOG_USER("KB: Toggle paginate / threshold mode, now: " <<
                          GetPagemode());
                //ShowStatusStr("Cluster viewer page mode",
                //              mClusterSelector->GetPagemode());
                break;

            default:
                keyHandled = false;
        }
        return keyHandled;
    }

/*
    bool ClusterKeyboardFunc(int c, int state)
    {
        bool keyHandled = true;

        if (!GetPagemode())
        {
            // when browsing clusters do not allow page flips, but
            // change cluster size instead.
            if (c == 'a' || c == 'A') c = 's';
            if (c == 'd' || c == 'D') c = 'w';
        }

        switch (c)
        {
            case 'S':
            case 's':
                ILOG_USER("KB: decrease selection size in cluster viewer");
                DecreaseSelectionSize();
                break;
            case 'w':
            case 'W':
                ILOG_USER("KB: decrease selection size in cluster viewer");
                IncreaseSelectionSize();
                break;

            case 'd':
                ILOG_USER("KB: move to next page in cluster viewer");
                mContext->MoveRelative(GetSelectionSize());
                Show(mContext);
                break;

            case 'a':
                ILOG_USER("KB: move to previous page in cluster viewer");
                mContext->MoveRelative(-GetSelectionSize());
                Show(mContext);
                break;

            case 'r':
            case 'R':
                ILOG_USER("KB: Toggle paginate / threshold mode");
                SetPagemode(!GetPagemode());
                ILOG_USER("KB: Toggle paginate / threshold mode, now: " <<
                          GetPagemode());
                //ShowStatusStr("Cluster viewer page mode",
                //              mClusterSelector->GetPagemode());
                break;

            default:
                keyHandled = false;
        }
        return keyHandled;
    }
*/
private:

    int GetWidth(int number)
    {
        int h = GetHeight(number);
        return (int)ceil((float)number / (float)h);
    }

    int GetHeight(int number)
    {
        int n = (int)ceil(sqrt((float)number));
        if (n > 8) n = 8;
        return n;
    }
    
    void ShowRelevantSquare()
    {
        int number = mSelectionSize;
        if (!mPaginated)
        {
            if (!CurrentContextHasSimilarities())
            {
                ILOG_DEBUG("Showing paginated mode, curr thread has no sims.");
            }
            else
                number = GetNumberForThreshold();
        }

        mCache->DoHide(mCache->GetViews());

        float xspacer = 0.65f;
        float yspacer = 0.55f;

        int     ctr = 0;
        float   bx  = -GetWidth(number)  * xspacer / 2.0f + 0.5f * xspacer;
        float   by  = -GetHeight(number) * yspacer / 2.0f + 0.5f * yspacer;
        ILOG_DEBUG("ShowRelevantSquare(" << number<< "): width=" <<
                   GetWidth(number) << " height=" << GetHeight(number));
        for (int i=0; i < GetHeight(number); i++)
        {
            for (int j=0; j < GetWidth(number); j++)
            {
                int item = GetRelevant(ctr);
                if (item < 0)
                {
                    ctr = number + 1;
                    break;
                }
                RotorView *v =
                    mCache->GetViewFor(mContext->GetName(), GetRelevant(ctr));
                float x = bx + xspacer * j;
                float y = -by - yspacer * i;
                v->MoveFrom(0.0f, 0.0f, -10.0f, 0.5f, 1.0f);
                v->MoveTo(x,y,-2.0f,0.5f,1.0f);

                if (++ctr > number)
                    break;
            }
            if (ctr > number)
                break;
        }

        mCache->DoCleanup(mCache->GetViews());
    }

    int GetRelevant(int pos)
    {
        int item = mContext->GetRelative(pos);
        return item;
    }

    KeyBindingsMap              mKeyBindings;
    RotorBrowserContext*        mContext;
    RotorViewCache*             mCache;

    Real64                      mThresholdDelta;

    int                         mSelectionSize;

    bool                        mThresholdDissim;
    bool                        mShowing;
    bool                        mPaginated;

    ILOG_VAR_DEC;

}; // class ThreadClusterSelector

ILOG_VAR_INIT(ThreadClusterSelector, Visualization.RotorBrowser);

}
}
}
#endif

---