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

---

RotorBrowserGUI.h

Go to the documentation of this file.

#ifndef Impala_Visualization_RotorBrowser_RotorBrowserGui_h
#define Impala_Visualization_RotorBrowser_RotorBrowserGui_h

#include "RotorBrowser.h"
//#include "RotorBrowserControl.h"

#include "OglGui/TextArea.h"
#include "OglGui/Window.h"

#include "Visualization/ImageSet.h"
#include "Visualization/Window.h"
#include "Visualization/VideoMinimap.h"

#include "Core/Trec/VisualQueryEngine.h"
#include "Sandbox/ork/ProgramNameReader.h"

namespace Impala {
namespace Visualization {
namespace RotorBrowser {

class RotorBrowserGUI:  public Visualization::Window,
                        public RotorBrowserListener,
                        public Visualization::ImagesListener
{
public:
    typedef Core::Trec::KeyframeResult              KeyframeResult;
    typedef Core::Trec::ShotResult                  ShotResult;
    typedef Core::Trec::VisualQueryEngine           VisualQueryEngine;
    typedef Core::Trec::ThreadSet                   ThreadSet;
    typedef Core::VideoSet::Segmentation            Segmentation;
    typedef Core::VideoSet::SegmentationDocument    SegmentationDocument;
    typedef std::list<RotorBrowserContext*>         RotorBrowserContextList;
    typedef std::list<KeyframeResult>               KeyframeResultList;

    RotorBrowserGUI(OglGui::Window *parent, int w, int h,ThreadSet *threadset,
                    SegmentationDocument *segdoc, int imW, int imH,
                    double imScale, int controlId, bool showLatestBookmarks,
                    bool enableMinimap = true) :
        Visualization::Window(parent, w, h, true)
    {
        mThreadSet          = threadset;
        mSegDoc             = segdoc;
        mRotorBrowser       = NULL;
        mRotorBrowserInfo   = NULL;
        mLastVisualKeyframe = -1;
        mLastVisualMode     = -1;
        mMinimapEnabled     = enableMinimap;

        SetControlId(controlId);

        BuildGui(imW, imH, imScale, showLatestBookmarks);
        // RvB: Next 2 lines for extra context info
        //mRotorBrowserInfo = new TextArea(this, 0, height-100, 240, 5, "");
        //mRotorBrowserInfo->SetTextColor(oglRED);
    }

    RotorBrowser* Browser()
    {
        return mRotorBrowser;
    }

    void SetBrowseMode(int mode)
    {
        mRotorBrowser->SetBrowseMode(mode);
    }

    void SetInitialQueryToMovies()
    {
        ILOG_DEBUG("setting shots_initialquery to first shot in each movie");
        // RvB: Fixed
        //ILOG_WARN("if called more than once this will crash. Fix me!");

        int nrVideos = mThreadSet->GetKeyframes()->GetNrVideos();
        std::list<ShotResult> shots;
        for (int i=0; i < nrVideos; i++)
        {
            int frame = mThreadSet->GetKeyframes()->GetFirstKeyframeVideo(i);
            int shot = mThreadSet->GetKeyframes()->GetShotId(frame);
            ShotResult r;
            r.shotid = shot;
            r.score = 1.0;
            r.rank = i + 1;
            shots.push_back(r);
        }
        mThreadSet->RemoveThread("shots_initialquery");
        mThreadSet->AddThreadShots("initialquery", shots);
        mRotorBrowser->ValidateContext("shots_initialquery");
        mRotorBrowser->UpdateViewsToContext();
        int mode = mRotorBrowser->GetBrowseMode();
        if (mode == RotorBrowser::MODE_CROSSBROWSER)
            mRotorBrowser->ReloadCrossBrowser();
        else if(mode == RotorBrowser::MODE_FORKBROWSER)
            mRotorBrowser->ReloadForkBrowser();
        else // RvB: I do not really know how to handle this one
            mRotorBrowser->ReloadInitial();
    }

    void DoQueryByRegion(int keyframe, float x, float y, float w, float h)
    {
        ILOG_DEBUG("external DoQueryByRegion for " << keyframe);
        mRotorBrowser->OnRectangleSelectByKeyframe(keyframe, x, y, w, h);
    }

    void ResetCrossBrowser()
    {
        mRotorBrowser->UpdateViewsToContext();
        mRotorBrowser->ReloadCrossBrowser();
    }

    void AddRotorBrowserListener(RotorBrowserListener *target)
    {
        mListeners.push_back(target);
    }

    void ResetRanking()
    {
        ILOG_DEBUG("ResetRanking()");
        mRotorBrowser->ResetRanking();
    }

    void FocusToBrowser()
    {
        mRotorBrowser->TakeFocus();
    }

    // allow for remote control(TM):
    void PressKey(int c, int state = 0)
    {
        mRotorBrowser->TakeFocus();
        mRotorBrowser->KeyboardFunc(c, state);
    }

    void SetProgramNames(Samples::ProgramNameReader *programs)
    {
        mRotorBrowser->SetProgramNames(programs);
    }


    int GetCenterShot()
    {
        if (mRotorBrowser != 0 && mRotorBrowser->GetActiveContext() != 0)
            return mRotorBrowser->GetActiveContext()->GetCenter();
        return -1;
    }

    bool GetShowMinimap()
    {
        return mMinimapVisible;
    }

    void SetShowMinimap(bool doShow)
    {
        if (mMinimapEnabled)
        {
            mMinimapVisible = doShow;
            mMinimap->SetVisible(doShow);
            if (mRotorBrowser != 0)
                mRotorBrowser->SetMinimapEnabled(doShow);
        }
    }

    virtual void HandleActivate()
    {
        ILOG_DEBUG( "HandleActivate()" );
        mRotorBrowser->ReloadInitial();
    }


private:

/************* NOTE TO SELF ***************
  for some reason the code below works, but will allow the app to crash when U
  is pressed, and mQbyR (WHICH IS NOT USED) is NOT INITIALIZED?!??
  verify, debug
*/

    void
    BuildGui(int imW, int imH, double viewScale, bool showLatestBookmarks)
    {
        int yOff = showLatestBookmarks ? 80 : 0;
        mRotorBrowser =
            new RotorBrowser(this, 0, yOff, W(), H()-yOff, mThreadSet, mSegDoc);
        mRotorBrowser->SetBorderFillShaded(1);
        mRotorBrowser->SetBorderType(5);
        mRotorBrowser->SetRoundness(10,10,10,10);
        mRotorBrowser->ConnectTo(this, ALLSIDES );
        mRotorBrowser->SetRotorBrowserListener(this);

        viewScale = viewScale / 2;

        // latest bookmarks bar code:
        mLatestBookmarks = 0;
        if (showLatestBookmarks)
        {
            //Window *bookmarkW = new Window(this, 4, 28, W()-8, imH*viewScale+8);
            OglGui::Window *bookmarkW =
                new OglGui::Window(this, 4, 28, W()-8, imH*viewScale+8);
            int nrImOnRow = bookmarkW->W() / (imW * viewScale);
            mLatestBookmarks = new ImageSet(bookmarkW, imW, imH, viewScale,
                                            nrImOnRow, 1);
            mLatestBookmarks->SetImagesListener(this, IM_BOOKMARKS);
            mLatestBookmarks->ActivateInfoBox(false);
            mLatestBookmarks->SetAllowDragging(false);
            mMaxBookmarkViews = nrImOnRow * 1;
        }

        // minimap code:
        mMinimap = 0;
        mMinimapVisible = false;
        if (mMinimapEnabled)
        {
            Segmentation* seg = mThreadSet->GetSegmentation();
            MapFunction *f = new VideoSquareMapFunction(seg,100,100);
            mMinimap = new VideoMinimap(f, this, W()-220, H()-220, 200, 200);
            mMinimap->SetRoundness(2,2,2,2);
            mMinimap->SetBorderType(4);
            mMinimap->SetBorderFillShaded(2);
            mMinimap->EnablePreviewWindow(mThreadSet);
            mRotorBrowser->RegisterShotTrails(mMinimap);
            mMinimapVisible = true;
        }
    }

private:
    virtual void KeyEvent(OglGui::Window *src, int c, int state)
    {
        ILOG_DEBUG( "KeyEvent(" << c << ", " << state << ")" );
        switch (c) {
        case 'm':
            ILOG_USER( "KB: set initialquery to movie start positions" );
            SetInitialQueryToMovies();
            break;
        }
        mRotorBrowser->TakeFocus();
    }

    void Reset()
    {
        ILOG_DEBUG( "Reset()" );
        if (mLatestBookmarks)
            mLatestBookmarks->RemoveImages();
        mRotorBrowser->ClearViewedCache();
    }

    virtual void ResetBrowserEvent()
    {
        Reset();
    }

    virtual void
    ContextMoveEvent(OglGui::Window* src, int direction, int position)
    {
        ILOG_DEBUG( "MoveEvent: " << direction << " position = " << position );
        SetRotorText();

        for (int i=0; i<mListeners.size();i++)
            mListeners[i]->ContextMoveEvent(src, direction, position);
        
        // add handlers to other images here
        // -- mThreadSet->GetKeyframes()->GetShotRKF(position);
    }

    virtual void
    ContextChangeEvent(OglGui::Window* src, RotorBrowserContext *newcontext)
    {
        SetRotorText();
        ILOG_DEBUG("ContextChangeEvent: new context = "<<newcontext->GetName());
        for (int i=0; i<mListeners.size();i++)
            mListeners[i]->ContextChangeEvent(src, newcontext);

    }

    virtual void
    BookmarkEvent(OglGui::Window* src, int shotid, bool isbookmarked)
    {
        ILOG_DEBUG( "BookmarkEvent: " << shotid << ": " << isbookmarked );

        for (int i=0; i<mListeners.size();i++)
            mListeners[i]->BookmarkEvent(src, shotid, isbookmarked);

        if (!mLatestBookmarks)
            return;

        if (isbookmarked)
        {
            mLatestBookmarks->AddImage(mThreadSet->GetImageByShotID(shotid),
                                       "Direct",mThreadSet->GetShotName(shotid),
                                       true, false, shotid);
            int nrIm = mLatestBookmarks->GetNrImages();
            if (nrIm > 0)
                mLatestBookmarks->MoveImageTo(nrIm-1, 0);
            if (mLatestBookmarks->GetNrImages() > mMaxBookmarkViews)
                mLatestBookmarks->RemoveImageByIndex(nrIm-1);
            else
                mLatestBookmarks->Redraw(); // to solve MoveTo bug
        }
        else // remove from mLatestBookmarks
        {   
            mLatestBookmarks->RemoveImageById(shotid);
            mLatestBookmarks->Redraw();
        }
    }

    void SetRotorText()
    {
        if (mRotorBrowserInfo == NULL)
            return;
        RotorBrowserContext* actContext = mRotorBrowser->GetActiveContext();
        std::ostringstream m;
        m << "Active context:   " << actContext->GetNiceName() << std::endl;
        m << "Current position: " << actContext->GetCenter() << std::endl;
        m << "Other contexts (" << mRotorBrowser->GetNrActiveContexts()-1;
        m << "): " << std::endl;

        RotorBrowserContextList contexts = mRotorBrowser->GetOtherContexts();
        RotorBrowserContextList::const_iterator context;

        for (context = contexts.begin(); context != contexts.end(); context++)
        {
            m << "  " << (*context)->GetNiceName() << " - " <<
               (*context)->GetThread()->GetShotPosition((*context)->GetCenter())
               << std::endl;
        }
        mRotorBrowserInfo->SetText(m.str());
    }


    virtual void ImageSelectionEvent(Visualization::ImagesWindow* src,
                                     int imIndex, void* listenerData)
    {
        // RvB: IM_VISRESULTS does not seem to be used anywhere
        if (listenerData == (void*) IM_VISRESULTS && mLastVisualKeyframe >= 0)
        {
            int browseMode = mRotorBrowser->GetBrowseMode();
            if (browseMode == RotorBrowser::MODE_CROSSBROWSER)
            {
                ILOG_USER("set shots_initialquery to visual set from bottom " <<
                          "view using keyframe " << mLastVisualKeyframe );
                SetInitialQueryToVisual();
            }
            else
            {
                ILOG_USER("adding results from bottom view to browser using " <<
                          "keyframe " << mLastVisualKeyframe );
                AddVisualToBrowser();
            }
        }

        // the following code is required only when mLatestBookmarks is used.
        if (listenerData == (void*)IM_BOOKMARKS)
        {
            ILOG_USER( "unbookmark " << imIndex << " from bottom view" );
            int row = Core::Column::Find(mSegDoc->GetBookmarked()->GetColumn1(),
                                        imIndex, 0,
                                        mSegDoc->GetBookmarked()->Size());
            Core::Table::RemoveRow(mSegDoc->GetBookmarked(), row);
            mLatestBookmarks->RemoveImageById(imIndex);
            mLatestBookmarks->Redraw();
            mRotorBrowser->Redraw();
        }

        mRotorBrowser->TakeFocus();
    }

    void AddVisualToBrowser()
    {
        if (mLastVisualMode == 1)
        {
            ILOG_DEBUG( "adding last query by region result to browser" );
            std::list<ShotResult> shots;
            std::map<int,bool> seen;
            int lastshot = mThreadSet->GetKeyframes()
                                ->GetShotId(mLastVisualKeyframe);
            for (KeyframeResultList::iterator i = mLastVisualKeyframes.begin();
                 i != mLastVisualKeyframes.end(); i++)
            {
                ShotResult r;
                int frameID = i->keyframeid;
                if (frameID == -1)
                {
                    ILOG_WARN("AddVisualToBrowser: " <<
                              "WARNING: erroneous frame in set." );
                    continue;
                }
                int shotID = mThreadSet->GetKeyframes()->GetShotId(frameID);
                if (seen.find(shotID) == seen.end())
                {
                    r.shotid = shotID;
                    r.score = i->score;
                    r.rank = i->rank;
                    shots.push_back(r);
                    seen[shotID] = true;
                }
            }
            mThreadSet->AddThreadShots("visual " + MakeString(lastshot), shots);
        }
        else
        {
            ILOG_DEBUG( "adding last visually similar result to browser" );
            VisualQueryEngine *e = new VisualQueryEngine(mThreadSet, 200);
            int lastVis = mLastVisualKeyframe;
            KeyframeResultList shots = e->QueryVisual(lastVis,true);
            int lastshot = mThreadSet->GetKeyframes()->GetShotId(lastVis);
            mThreadSet->AddThreadShots("visual " + MakeString(lastVis), shots);
        }
    }


    void SetInitialQueryToVisual()
    {
        if (mLastVisualMode == 1)
        {
            ILOG_DEBUG("setting shots_initialquery to " <<
                       "last query by region result");
            mThreadSet->RemoveThread("shots_initialquery");
            std::list<ShotResult> shots;
            std::map<int,bool> seen;
            for (KeyframeResultList::iterator i=mLastVisualKeyframes.begin();
                 i !=mLastVisualKeyframes.end(); i++)
            {
                ShotResult r;
                int frameID = i->keyframeid;
                if (frameID == -1)
                {
                    ILOG_WARN( "SetInitialQueryToVisual: " <<
                               "WARNING: erroneous frame in set." );
                    continue;
                }
                int shotID = mThreadSet->GetKeyframes()->GetShotId(frameID);
                if (seen.find(shotID) == seen.end())
                {
                    r.shotid = shotID;
                    r.score = i->score;
                    r.rank = i->rank;
                    shots.push_back(r);
                    seen[shotID] = true;
                }
            }
            mThreadSet->AddThreadShots("initialquery", shots);
            mRotorBrowser->ReloadCrossBrowser();
        }
        else
        {
            ILOG_DEBUG("setting shots_initialquery to " <<
                       "last visually similar result" );
            mThreadSet->RemoveThread("shots_initialquery");
            VisualQueryEngine *e = new VisualQueryEngine(mThreadSet, 200);
            KeyframeResultList shots = e->QueryVisual(mLastVisualKeyframe,true);
            mThreadSet->AddThreadShots("initialquery", shots);
            mRotorBrowser->ReloadCrossBrowser();
        }
    }

    int                                 mMaxBookmarkViews;
    int                                 mNrVisualShown;
    int                                 mLastVisualKeyframe;
    int                                 mLastVisualMode;

    bool                                mMinimapEnabled;
    bool                                mMinimapVisible;

    ThreadSet*                          mThreadSet;
    SegmentationDocument*               mSegDoc;
    RotorBrowser*                       mRotorBrowser;
    OglGui::TextArea*                   mRotorBrowserInfo;
    Visualization::ImageSet*            mLatestBookmarks;
    Visualization::VideoMinimap*        mMinimap;
    KeyframeResultList                  mLastVisualKeyframes;

    std::vector<RotorBrowserListener*>  mListeners;

    static const int IM_BOOKMARKS       = 1;
    static const int IM_VISRESULTS      = 2;

    ILOG_VAR_DEC;

}; // class RotorBrowserGUI

ILOG_VAR_INIT(RotorBrowserGUI, Visualization.RotorBrowser);

} // namespace RotorBrowser
} // namespace Visualization
} // namespace Impala 
#endif

---