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

---

RotorViewCache.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef Impala_Visualization_RotorBrowser_RotorViewCache_h
#define Impala_Visualization_RotorBrowser_RotorViewCache_h

#include <list>
//#include "OglGui/Window.h"
#include "RotorView.h"
#include "Core/Trec/ThreadSet.h"
#include "Core/Table/AnnotationTable.h"


namespace Impala {
namespace Visualization {
namespace RotorBrowser {

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

class RotorViewCache : public RotorViewCacheResolver
{
public:
    typedef std::list<RotorView*>                   RotorViewList;
    typedef std::list<RotorDoDView*>                RotorDoDViewList;
    typedef Core::Trec::Thread                      Thread;
    typedef Core::Trec::ThreadSet                   ThreadSet;
    typedef Impala::Core::Table::AnnotationTable    AnnotationTable;

    //RotorViewCache(Window *window, ThreadSet *threadset,
    //               RotorViewListener *listenerTarget)
    RotorViewCache(OglGui::Window *window, ThreadSet *threadset,
                   RotorViewListener *listenerTarget)
    {
        mWnd            = window;
        mThreadSet      = threadset;
        mListenerTarget = listenerTarget;
        mHits           = 0;
        mMisses         = 0;
        mRHits          = 0;
        mRMisses        = 0;

        mShotViewed     = new AnnotationTable();
    }

    static RotorView* OGLVIEW3DToRotorView(OGLVIEW3D* v)
    {
        if (!v) return 0;
        return (RotorView*)view3DSys.GetUserData(v, RotorView::VIEW_ROTORVIEW);
    }

    void DoHide(RotorViewList views)
    {
        RotorViewList::const_iterator i;
        for (i=views.begin(); i != views.end(); i++)
            (*i)->Hide();
    }

    void DoCleanup(RotorViewList views)
    {
        RotorViewList::const_iterator i;
        for (i=views.begin(); i != views.end(); i++)
        {
            if ((*i)->IsUnused())
            {
                if (mUnusedViewCache.size() < 200)
                    mUnusedViewCache.push_back((*i)->RecycleView());
                delete *i;
            }
        }
    }

    /* retrieve active RotorViews, using OGL */
    RotorViewList GetViews()
    {
        RotorViewList   views;
        RotorView*      v;

        for(LIST* o=mWnd->GetOGLWND()->objectList ; o ; o=o->next)
        {
            if (v = OGLVIEW3DToRotorView((OGLVIEW3D *) o->info))
                views.push_back(v);
        }
        return views;
    }

    // RvB: REMARK: Not used
    /* retrieve active RotorViews from a single set, using OGL */
    RotorViewList GetViews(String name)
    {
        RotorViewList views;

        for(LIST* o=mWnd->GetOGLWND()->objectList ; o ; o=o->next)
        {
            RotorView* v = OGLVIEW3DToRotorView((OGLVIEW3D*) o->info);
            if (v && v->GetName() == name)
                views.push_back(v);
        }
        return views;
    }
    /* 
     * tries to find a recyclable (=unused, but with texture mapped)
     * view matching the given resolution. Will return any other view
     * if exact resolution cannot be found.
     */
    // RvB: NOTE: Exact resolution is not important !!!!!
    // TextureW and TextureH must be at least w,h
    RotorDoDView *FindRecycledView(int w, int h)
    {
        for (RotorDoDViewList::iterator i = mUnusedViewCache.begin();
             i != mUnusedViewCache.end(); i++)
        {
            if ((*i)->HasResolution(w,h)) {
                RotorDoDView* recycleMe = *i;
                mUnusedViewCache.erase(i);
                mRHits++;
                return recycleMe;
            }
        }
        //ILOG_DEBUG("FindRecycledView: no resolution match. Returning first.");
        RotorDoDView* recycleMe = mUnusedViewCache.front();
        mUnusedViewCache.pop_front();
        mRMisses++;
        return recycleMe;
    }

    /*
     * note; this class works under the assumption that every
     * thread-pos combination will be visible only once
     *
     * future improvements:
     *  - re-use cached version of something that has exactly the
     *    same resolution.
     */
    RotorView* GetViewFor(String thread, int pos)
    {
        RotorView *v = FindViewFor(thread, pos);
        if (v==NULL)
        {
            mMisses++;
            if (mUnusedViewCache.size() > 0)
                v = new RotorView(mWnd,mThreadSet,thread,pos,0.0,0.0,this);
            else
                v = new RotorView(mWnd,mThreadSet,thread,pos,0.0,0.0);
        }
        v->SetViewListener(mListenerTarget);
        v->Show();
        v->UpdateBookmarkState();
        return v;
    }

    RotorView* FindViewFor(String thread, int pos)
    { 
        for(LIST* o=mWnd->GetOGLWND()->objectList ; o ; o=o->next)
        {
            RotorView* v = OGLVIEW3DToRotorView((OGLVIEW3D *) o->info);
            if (v && v->IsSameAs(thread, pos))
            {
                mHits++;
                return v;
            }
        }
        return NULL;
    }

    void CacheReport()
    {
        ILOG_DEBUG("RotorViewCache usage statistics:");
        ILOG_DEBUG("cache total:    " << mHits + mMisses <<
                   " ( = hits + misses ) ");
        ILOG_DEBUG("cache hits:     " << mHits);
        ILOG_DEBUG("cache misses:   " << mMisses <<
                   " ( = recycled hits + total recreations)");
        ILOG_DEBUG("recycled hits:  " << mRHits );
        ILOG_DEBUG("total recreate: " << mRMisses );
    }

    bool ThreadExists(CString threadname)
    {
        return mThreadSet->GetThreadByName(threadname) ? true : false;
    }

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

    // shot viewed probability scores:

    // update code: this function should be called for all instances where
    // a shot is visible to the user,
    // probability: additive score which indicates how big the chance is that
    //              the user actually took notice of the shot.

    void ShotIsViewed(int shot, double probability)
    {
        Core::VideoSet::Segmentation* seg = mThreadSet->GetSegmentation();
        return QuidShotIsViewed(seg->GetQuidShot(shot), probability);
    }

    void QuidShotIsViewed(Quid shot, double probability)
    {
        double ipro = probability;
        if (probability > 1.0) probability = 1.0;
        if (probability < 0.0) probability = 0.0;

        if (!mShotViewed->IsAnnotated(shot))
            mShotViewed->Add(shot, probability);
        else
        {
            int rank = mShotViewed->GetIndex(shot);
            probability += mShotViewed->Get2(rank);
            if (probability > 1.0) probability = 1.0;
            mShotViewed->Set2(rank, probability);
        }
        //ILOG_DEBUG("ShotIsViewed(" << QuidObj(shot) << ", " << ipro <<
        //           "): " << probability);
    }

    double GetViewedProbability(int shot)
    {
        Core::VideoSet::Segmentation* seg = mThreadSet->GetSegmentation();
        return GetQuidViewedProbability(seg->GetQuidShot(shot));
    }

    double GetQuidViewedProbability(Quid shot)
    {
        if (mShotViewed->IsAnnotated(shot))
            return mShotViewed->GetQualification(shot);
        else
            return 0.0;
    }

    void ClearShotViewed()
    {
        ILOG_DEBUG("ClearShotViewed()");
        mShotViewed->SetEmpty();
    }

    AnnotationTable* GetViewedShots()
    {
        return mShotViewed;
    }

    private:

    //Window*         mWnd;
    OglGui::Window*         mWnd;
    ThreadSet*              mThreadSet;
    RotorViewListener*      mListenerTarget;
    AnnotationTable*        mShotViewed;

        RotorDoDViewList        mUnusedViewCache;

    int                     mHits;
    int                     mMisses;
    int                     mRHits;
    int                     mRMisses;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(RotorViewCache, Visualization.RotorBrowser);
}
}
}

#endif

---