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

---

mainTrecSearch.cpp

Go to the documentation of this file.

#include "OglGui/ProgressBar.h"
#include "OglGui/Tabs.h"
#include "OglGui/TextArea.h"

#include "Visualization/AppController.h"
#include "Visualization/SearchJudgeGui.h"
#include "Visualization/SegmentationDocumentGuiStills.h"
#include "Visualization/SegmentationDocumentGuiMain.h"
#include "Visualization/RotorBrowser/RotorBrowserGUI.h"
#include "Visualization/ThreadSetGui.h"
#include "Visualization/SearchTopicGui.h"
#include "Visualization/GUI/HelpViewer.h"

#include "Util/StringParser.h"
#include "Core/Trec/TrecTopic.h"
#include "Core/VideoSet/MakeSegmentationDocument.h"

#include "Sandbox/ork/QueryGui.h"
#include "Sandbox/ork/SortGui.h"
#include "Sandbox/ork/ShotDetailWindow.h"
//#include "Sandbox/ork/MiniMapGenerator.h"

#include "Application/videolympics/VideolympicsClient.h"

// since we are not using libraries:
#include "Link/ImpalaLib.cpp"
#include "OglGui/OglLib.cpp"
//#undef BOOL


namespace Impala {
namespace Application {

//using namespace Visualization;

class WindowTrecSearch :
                    public Visualization::Window,
                    public OglGui::TabsListener,
                    public Visualization::RotorBrowser::RotorBrowserListener,
                    public Visualization::SearchTopicGuiListener,
                    public SortGuiListener,
                    public QueryGuiListener
{
public:
    typedef Core::Trec::Thread                              Thread;
    typedef Core::Trec::ThreadVirtual                       ThreadVirtual;
    typedef Core::Trec::ThreadBookmarked                    ThreadBookmarked;
    typedef Core::Table::SimilarityTableSet                 SimilarityTableSet;

    typedef OglGui::ProgressBar                             ProgressBar;
    typedef OglGui::StaticText                              StaticText;

    typedef Visualization::AppController                    AppController;
    typedef Visualization::AppControlDoc                    AppControlDoc;
    typedef Visualization::RotorBrowser::RotorBrowserGUI    RotorBrowserGUI;
    typedef Visualization::RotorBrowser::RotorBrowser       RotorBrowser;
    typedef Visualization::SearchTopicGui                   SearchTopicGui;
    typedef Visualization::SearchJudgeGui                   SearchJudgeGui;
    typedef Visualization::ThreadSetGui                     ThreadSetGui;
    typedef Visualization::GUI::HelpViewer                  HelpViewer;

    typedef Visualization::SegmentationDocumentGuiMain            
                                                  SegmentationDocumentGuiMain;
    typedef Visualization::SegmentationDocumentGuiStills            
                                                  SegmentationDocumentGuiStills;
    const static int BUT_SHOW_RESULT    = 1;
    const static int BUT_SAVE_RESULT    = 2;
    const static int BUT_CLEAR_RESULT   = 3;

    const static int TAB_TOPIC          = 0;
    const static int TAB_QUERY          = 1;
    const static int TAB_MDBROWSER      = 2;
    const static int TAB_SORT           = 3;
    const static int TAB_THREAD         = 4;
    const static int TAB_GRID           = 5;
    const static int TAB_CROSS          = 6;
    const static int TAB_PLAY           = 7;
    const static int TAB_STILLS         = 8;
    const static int TAB_PLOT           = 9;
    const static int TAB_JUDGE          = 10;
    const static int TAB_HELP           = 11;
    const static int TAB_DETAILS        = 12;
    const static int TAB_SORT_NEGATIVE  = 13;

    const static int MODE_CROSSBROWSER  = Visualization::RotorBrowser::
                                          RotorBrowser::MODE_CROSSBROWSER;
    const static int MODE_FORKBROWSER   = Visualization::RotorBrowser::
                                          RotorBrowser::MODE_FORKBROWSER;


    WindowTrecSearch(int width, int height) :
        Visualization::Window(0, 0, width, height, true)
    {
        mOglWnd->topTitle = "MediaMill Semantic Video Search Engine";

        CmdOptions& options = CmdOptions::GetInstance();
        mViewScale = options.GetDouble("viewScale");

        ILOG_STARTACTION("loading configuration", ILOG_LEVEL_INFO);
        InitConfig();
        ILOG_ENDACTION("loading configuration");

        ILOG_STARTACTION("loading data", ILOG_LEVEL_INFO);
        InitData();
        ILOG_ENDACTION("loading data");

        /*
        if (options.GetString("minimap") != "")
        {
            int max = options.GetInt("minimapdepth");
            MiniMapGenerator *g = new MiniMapGenerator(mThreadSet, max);
            g->Generate(options.GetString("minimap"));
            return;
        }
        */

        ILOG_STARTACTION("building GUI", ILOG_LEVEL_INFO);
        BuildGUI(width, height);
                ILOG_DEBUG( "BuildGUI returned.");

        if (mSearchTopicGui)
            mSearchTopicGui->ShowTopic(0);
                ILOG_DEBUG( "initial topic set.");

        mTopicRunning = false;
        SetInterval(0.5);
        ILOG_ENDACTION("building GUI");
//        ILOG_INFO("PROCEEDING WITH ACTIVE LEARNING EXPERIMENT");
//        mQueryGui->SetQueryFromTopic(mSearchTopic);
//        mQueryGui->DoActiveLearningBouke();
    }

    // specialization of base classes

    virtual void HandleCycleGUI()
    {
        UpdateProgress();
    }

    virtual void KeyEvent(OglGui::Window *src, int c, int state)
    {
         // F1 .. F4 and F12
        if (c >=oglFUNC(1) && c < oglFUNC(5) || c == oglFUNC(12))
        {
            switch (c)
            {
            case oglFUNC(1):
                if (mSearchTopicGui)
                    mTabs->SetActiveTab(TAB_TOPIC, false);
                break;
            case oglFUNC(2):
                if (mQueryGui && !(mUseWnd2 == "Query"))
                    mTabs->SetActiveTab(TAB_QUERY, false);
                break;
            case oglFUNC(3):
                mTabs->SetActiveTab(TAB_MDBROWSER, false);
                break;
            case oglFUNC(4):
                mTabs->SetActiveTab(TAB_SORT, false);
                break;
            case oglFUNC(12):
                if (state & oglShift)
                {
                    ILOG_USER("SHIFT - F12 pressed - instant exit.");
                    exit(0); 
                }
                break;
            }
        }

        if (mWnd2 && (c == 'u'))
        {
            ILOG_USER( "KB: update stills for active shot" );
            if (mDetailWindow)
                mDetailWindow->HandleNewKey(c, state);
            if (mSegDocStills)
                mSegDocStills->HandleNewKey(c, state);
        }
    }

    virtual void
    TabSelectionEvent(OglGui::Tabs* src, int tabNr, void* listenerData,
                      int tabControlData)
    {
        AppController::Instance().SetCurrentControl(tabControlData);

        ILOG_ENDACTION("tab");
        switch (tabControlData)
        {
        case TAB_THREAD:
            ILOG_USER("tab switch to TAB_THREAD");;
            break;
        case TAB_QUERY:
            ILOG_USER("tab switch to TAB_QUERY");
            if (mSearchTopic)
            {
                if (!mTopicRunning)
                {
                    ILOG_DEBUG("Setting initial query for topic " <<
                               mSearchTopic->GetCurTopicNum() << ": ");
                    ILOG_DEBUG( "QUERY: " << mSearchTopic->GetCurTopicText());
                    if (mQueryGui)
                        mQueryGui->SetQueryFromTopic(mSearchTopic);

                    //mSearchTopic->StartTimer();
                    mTopicRunning = true;
                }
                // XXX TODO
            }
            break;
        case TAB_MDBROWSER:
            ILOG_USER( "tab switch to TAB_MDBROWSER" );
            if (mDisableQueryTab)
            {
                ILOG_DEBUG("Query tab disabled, initializing default browser.");
                mBrowserGui->SetInitialQueryToMovies();
                if (mInitialBrowser == 1)
                {
                    ILOG_DEBUG( "starting CrossBrowser" );
                    mBrowserGui->SetBrowseMode(MODE_CROSSBROWSER);
                }
                if (mInitialBrowser == 3)
                {
                    ILOG_DEBUG( "starting ForkBrowser" );
                    mBrowserGui->SetBrowseMode(MODE_FORKBROWSER);
                }
            }
            break;
        case TAB_SORT:
            ILOG_USER( "tab switch to TAB_SORT" );
            break;
        case TAB_TOPIC:
            ILOG_USER( "tab switch to TAB_TOPIC" );
            break;
        case TAB_JUDGE:
            Thread* t = mThreadSet->GetThreadByName("shots_supplement");
            mSearchJudgeGui->DoJudgement(mSegDoc->GetBookmarked(),t);
            break;
        }

        ILOG_STARTACTION("tab", ILOG_LEVEL_INFO);
    }

    virtual void QueryDoneEvent()
    {
        ILOG_SYSTEM("Query pane done. Going to browser");
        mTabs->SetActiveTab(TAB_MDBROWSER, false);
        if (mInitialBrowser == 1)
        {
            ILOG_DEBUG( "starting CrossBrowser" );
            mBrowserGui->SetBrowseMode(MODE_CROSSBROWSER);
        }
        mBrowserGui->ResetRanking();
    }

    // Start RotorBrowserListener
    virtual void
    BookmarkEvent(OglGui::Window* src, int shotid, bool isbookmarked)
    {
        if (mVideolympicsClient && isbookmarked)
        {
            ILOG_DEBUG("Registering shot ID " << shotid <<
                       " with contest server.");
            String naam = mThreadSet->GetShotName(shotid);
            mVideolympicsClient->SendShot(naam);
        }
    }

    virtual void
    ContextMoveEvent(OglGui::Window* src, int direction, int position)
    {
        if (mWnd2 && mUseWnd2 == "Stills" && mSegDocStills)
            mSegDocStills->HandleNewFile();
        // RvB: Ik weet niet of altijd updaten van Details ook in rotorbrowser
        // gewenst is. Anders zoals bij stills een update checkbox maken?
        /*
        if (mWnd2 && mUseWnd2 == "Details" && mDetailWindow)
            mDetailWindow->HandleNewFile();
        */
    }
    // End RotorBrowserListener

    virtual void
    TopicSelectionEvent(SearchTopicGui* src, int topic, void* userData)
    {
        //ILOG_ENDACTION("topic");
        //ActionLogger::OpenPartLog();
        ILOG_USER( "new topic selected: " << topic );
        ILOG_STARTACTION("topic", ILOG_LEVEL_INFO);
        mTopicRunning = false;
        
        mDidTimeAlert = false;
        SetBg(mBackgroundColor);
        SetInterval(0.5);

        if (mJudge && mJudgeInBrowser)
        {
            String judgetopic = mSearchTopic->GetCurTopicNum();
            if (!mJudge->HasTopic(judgetopic))
            {
                ILOG_ERROR("No judgement available for topic " << judgetopic);
                return;
            }

            ILOG_SYSTEM("Showing judgements in browser: resetting bookmarks");
            ThreadBookmarked *positive = (ThreadBookmarked*)
                mThreadSet->GetThreadByName("bookmarked");
            ThreadBookmarked *negative = (ThreadBookmarked*)
                mThreadSet->GetThreadByName("bookmarked_negative");

            positive->Clear();
            negative->Clear();

            ILOG_SYSTEM("Loading judgements as bookmarks...");
            std::vector<String> shots = mJudge->GetJudgedShots(judgetopic);
            std::vector<int> values = mJudge->GetJudgedValues(judgetopic);

            for (int i=0; i<shots.size(); i++)
            {
                String name = shots[i];
                int shot = mThreadSet->GetSegmentation()->GetShotId(name);
                int keyframe = mThreadSet->GetKeyframes()->GetShotRKF(shot);
                if (values[i] == 0) // negative:
                    negative->AddShot(shot, keyframe);
                if (values[i] == 1) // positive:
                    positive->AddShot(shot, keyframe);
            }
        }
    }

    virtual bool RequestSaveFinalEvent()
    {
        return SaveFinalResult();
    }
   
    virtual bool RequestComputeFinalEvent()
    {
        return ComputeFinalResult();
    }


    virtual void DisplayFunc()
    {
        static bool initialized = false;

        if (!initialized)
        {
            initialized = true;
            ScaleChildren(0, true);
            SetReposChildren(false, true);
        }
#ifdef APP_CONTROLLER_ALT
        HandleCycleGUI();
#endif
        Window::DisplayFunc();
    }

private:

    // initialization
    void InitConfig()
    {
        CmdOptions& options = CmdOptions::GetInstance();

        String yearStr          = options.GetString("year");
        mVideoSetName           = options.GetString("videoSet");
        mConceptSetName         = options.GetString("conceptSet");
        mConceptCatName         = options.GetString("conceptCat");
        mConceptQualityName     = options.GetString("conceptQuality");
        mConceptMappingName     = options.GetString("conceptMapping");
        mQbyExampleSet          = options.GetString("queryByExampleSet");
        mTrecTopicSetName       = options.GetString("trecTopicSet");
        mJudgeFileName          = options.GetString("judgeFile");
        mJudgeInBrowser         = options.GetBool("judgeInBrowser");
        mSearchTopicImages      = options.GetString("searchTopicImages");
        mSearchTopicThumbnails  = options.GetString("searchTopicThumbnails");
        mAutomaticResultsDir    = options.GetString("automaticResultsDir");
        mShowMinimap            = options.GetBool("enableMinimap");
        mImageStills            = options.GetBool("imageStills");
        mKeyServer              = options.GetString("keyServer");
        mWeibullScales          = options.GetInt("weibullScales");
        mNrWeibullLevels        = options.GetInt("nrWeibullLevels");
        mLoadWeibull            = !options.GetBool("noLoadWeibull");
        mUseWnd2                = options.GetString("useWnd2");
        mUseCross               = options.GetBool("useCross");
        mShowAnno               = options.GetBool("showAnno");
        mFilterLanguage         = options.GetBool("filterLanguage");
        mUseVisualRect          = options.GetBool("useVisualRect");
        mInitialBrowser         = options.GetInt("initialbrowser");
        mDisableQueryTab        = options.GetBool("disableQueryTab");
        mDisableStillsTab       = options.GetBool("disableStillsTab");
        mDisableDetailsTab      = options.GetBool("disableDetailsTab");
        mThumbWidth             = options.GetInt("thumbWidth");
        mThumbHeight            = options.GetInt("thumbHeight");

        mConceptModel           = options.GetString("conceptModel");
        mConceptFeature         = options.GetString("conceptFeature");

        mLogoAnim               = options.GetBool("logoAnim");
        String logoFile         = options.GetString("logoFile");

        mLogoIm = 0;
        if (!logoFile.empty())
          Core::Array::ReadJpg(mLogoIm,logoFile,&Util::Database::GetInstance());

        mYear = atol(yearStr);
        //mBackgroundColor = 0xff555566;
        mBackgroundColor = OglColorStr(options.GetString("wndBg").c_str());
    }

    void InitData()
    {
        mSegDoc     = Core::VideoSet::MakeSegmentationDocument(mVideoSetName);
        mVidSet     = mSegDoc->GetVideoSet();
        mKeyframes  = mSegDoc->GetKeyframes();
        mShots      = mSegDoc->GetSegmentation();
        
        InitDataVideoOlympics();
        InitDataConceptRanking();
        InitDataQueryByExample();
        InitDataThreadFile();
        InitDataTrecTopic();
        InitDataThreadSet();
        InitDataSearchJudge();

        mProgramNames = new ProgramNameReader(mThreadSet->GetSegmentation());

        mDidTimeAlert = false;
    }

    void InitDataVideoOlympics()
    {
        CmdOptions& options = CmdOptions::GetInstance();
        // VideOlympics showcase event contest server connection
        if (!options.GetString("videolympicsServer").empty())
        {
            ILOG_INFO("VideOlympics contest client: enabled.");
            mVideolympicsClient =
                new Application::Videolympics::VideolympicsClient(
                        options.GetString("videolympicsServer"),
                        options.GetInt("videolympicsPort"),
                        options.GetInt("videolympicsTeam"));
        }
        else
        {
            mVideolympicsClient = NULL;
            ILOG_DEBUG("VideOlympics contest client: disabled.");
        }
    }

    void InitDataConceptRanking()
    {
        mConceptRanking = 0;
        if (mConceptSetName.empty())
        {
            ILOG_WARN("concept reading disabled. No concepts available.");
            return;
        }

        ILOG_STARTACTION("reading concept ranking", ILOG_LEVEL_DEBUG);
        if (mYear <= 2006)
        {
            std::vector<String> conceptNames;
            FileReadString(std::back_inserter(conceptNames), mConceptSetName);
            mConceptRanking = new SimilarityTableSet(conceptNames,0);
            String dir = FileNameBase(mConceptSetName);
            String fileBase =
                mVidSet->GetFilePathVideoIndex(dir,conceptNames[0]+"_rank",
                                               false,false);
            mConceptRanking->LoadRanks(FileNamePath(fileBase),
                                       mVidSet->GetDatabase());
            // to convert to binary
            // mConceptRanking->SaveRanks(FileNamePath(fileBase), true);
        }
        else
        {
            mConceptRanking = SimilarityTableSet::MakeFromFile
                    (mVidSet,mConceptSetName,mConceptModel,mConceptFeature);
        }
        // if (mConceptRanking)
        //    StripConceptNames();
        // 3-9-2007: removed for Cees.2007 compliance.
    }

    void InitDataQueryByExample()
    {
        mQbyExampleRanking = 0;
        if (!mQbyExampleSet.empty())
        {
            ILOG_STARTACTION("reading query by example results",
                             ILOG_LEVEL_DEBUG);
            mQbyExampleRanking = SimilarityTableSet::MakeFromFile
                        (mVidSet,mQbyExampleSet,mConceptModel,mConceptFeature);
            ILOG_ENDACTION("reading query by example results");
        }
        else
        {
            ILOG_WARN("query by example disabled. No data available.");
        }
    }

    void InitDataThreadFile()
    {
        CmdOptions& options = CmdOptions::GetInstance();
        String tfile = options.GetString("threadFile");
        if (!tfile.empty()) 
        {
            ILOG_STARTACTION("reading threads", ILOG_LEVEL_INFO);
            std::vector<String> threadNames;
            FileReadString(std::back_inserter(threadNames), tfile);
            mThreadRanking = new SimilarityTableSet(threadNames,0);
            String fileBase = mVidSet->GetFilePathVideoIndex
                               ("threads", threadNames[0]+"_rank",false, false);
            mThreadRanking->LoadRanks(FileNamePath(fileBase),
                                      mVidSet->GetDatabase());
            // to convert to binary
            //mConceptRanking->SaveRanks(FileNamePath(fileBase), true);
            ILOG_ENDACTION("reading threads");
          
        }
        else
        {
            ILOG_WARN("semantic threads disabled. No semantic threads found.");
            mThreadRanking = 0;
        }
    }

    void InitDataTrecTopic()
    {
        mTrecTopic = 0;
        mSearchTopic = 0;
        if (! mTrecTopicSetName.empty())
        {
            mTrecTopic = new Core::Trec::TrecTopic(mTrecTopicSetName,
                                                   MakeString(mYear));
            mSearchTopic = mTrecTopic;
        }
        else
        {
            Core::ImageSet::ImageSet* imSet = 0;
            Core::ImageSet::ImageSet* thumbSet = 0;
            if (! mSearchTopicImages.empty())
                imSet = Core::ImageSet::MakeImageSet(mSearchTopicImages);
            if (! mSearchTopicThumbnails.empty())
                thumbSet = Core::ImageSet::MakeImageSet(mSearchTopicThumbnails);
            if (imSet || thumbSet)
                mSearchTopic = new Core::Trec::SearchTopic(imSet, thumbSet, 0);
        }
    }

    void InitDataThreadSet()
    {
        typedef Core::ImageSet::ImageSet ImageSet;
        ImageSet* imSetKeyfr = mSegDoc->GetImSetKeyframes(false);
        ImageSet* imSetThumb = mSegDoc->GetImSetKeyframes(true);
        mThreadSet =
            new Core::Trec::ThreadSet(mShots,mKeyframes,imSetThumb,imSetKeyfr);
        mThreadSet->AddThreadTime();
        mThreadSet->AddThreadBookmarked(mSegDoc->GetBookmarked());
        mThreadSet->AddThreadBookmarked("negative");
        mThreadSet->AddThreadHistory();

        mThreadSet->AddThreadVirtual("hidden");
        ((ThreadVirtual*)mThreadSet->GetThreadByName("virtual_hidden"))
            ->AddThread(mThreadSet->GetThreadByName("bookmarked"));

        if (mConceptRanking != 0)
        {
            ILOG_STARTACTION("adding concept threads", ILOG_LEVEL_INFO);
            for (int i=0 ; i<mConceptRanking->NrTables() ; i++)
                mThreadSet->AddThreadRank(mConceptRanking, i);
            ILOG_ENDACTION("adding concept threads");
        }

        if (mQbyExampleRanking != 0)
        {
            ILOG_STARTACTION("adding query by example threads",ILOG_LEVEL_INFO);
            for (int i=0 ; i<mQbyExampleRanking->NrTables() ; i++)
                mThreadSet->AddThreadRank(mQbyExampleRanking, i);
            ILOG_ENDACTION("adding query by example threads");
        }
    
        if (mThreadRanking != 0)
        {
            ILOG_STARTACTION("adding semantic threads", ILOG_LEVEL_INFO);
            for (int i=0 ; i<mThreadRanking->NrTables() ; i++)
                mThreadSet->AddThreadRank(mThreadRanking, i);
            ILOG_ENDACTION("adding semantic threads");
        }

        ILOG_STARTACTION("adding visual similarity", ILOG_LEVEL_INFO);
        ILOG_STARTACTION("adding visual similarity - Lab histograms",
                          ILOG_LEVEL_INFO);
        mThreadSet->AddThreadVisualSimilarity("labhistogram");
        ILOG_ENDACTION("adding visual similarity - Lab histograms");

        ILOG_STARTACTION("adding visual similarity - Weibull",ILOG_LEVEL_INFO);
        mThreadSet->AddThreadVisualSimilarity("vissem");
        ILOG_ENDACTION("adding visual similarity - Weibull");

        ILOG_STARTACTION("adding visual similarity - Fusion Vissem/Gabor",
                         ILOG_LEVEL_INFO);
        mThreadSet->AddThreadVisualSimilarity("fusionvissemgabor");
        ILOG_ENDACTION("adding visual similarity - weibull");

        ILOG_STARTACTION("adding visual similarity - Fusion Vissem/Gabor",
                         ILOG_LEVEL_INFO);
        mThreadSet->AddThreadVisualSimilarity("vissemgabor");
        ILOG_ENDACTION("adding visual similarity - Gabor");

        ILOG_ENDACTION("adding visual similarity");
    }

    void InitDataSearchJudge()
    {
        mJudge = 0;
        if (mJudgeFileName != String(""))
        {
            mJudge = new Core::Trec::SearchJudge(mJudgeFileName);
            mJudge->Stats();
        }
    }

    void HandleInitSecondWindow(int wndW, int wndH)
    {
        mWnd2 = 0;
        //if (mUseWnd2 != String("") && mUseWnd2 != String("None"))
        if (mUseWnd2 != "" && mUseWnd2 != "None")
        {
            mWnd2 = new Visualization::Window(wndW+6, 0, wndW, wndH);
                        ILOG_DEBUG( "BuildGUI: 2nd window enabled.");
        }
        else
            mUseWnd2 = "";
    }

    void BuildGUI(int wndW, int wndH)
    {
        int nrImOnRow = wndW / (mThumbWidth * mViewScale + 6);

        HandleInitSecondWindow(wndW, wndH);

        mTabs = new OglGui::Tabs(this, 0, 0, wndW, wndH, 90, 22);
        mTabs->SetTabsListener(this);

        //        BuildTimeLeftIndicator();
        mTimeLeft = 0; // todo: add option in ini to either build timer or disable it 
        BuildSearchTopicGui(nrImOnRow);
        BuildQueryGui();
        BuildRotorBrowserGui();
        BuildSortGui();
        BuildSortNegativeGui();
        BuildThreadSetGui(nrImOnRow);
        BuildGrid(nrImOnRow);
        BuildDetails();
        BuildStills(nrImOnRow);
        BuildSearchJudgeGui(nrImOnRow);
        BuildHelpGui();
                ILOG_DEBUG( "BuildGUI: tabs created.");

        mTabs->SetActiveTab(0);
        SetBg(mBackgroundColor);
    }

    void BuildTimeLeftIndicator()
    {
        int tLeftW = 200;
        mTimeLeft = new ProgressBar(this, W()-tLeftW-4, H()-28, tLeftW, 26);
        mTimeLeft->SetBorderType(BEV_LINE);
        mTimeLeft->SetRoundness(0,0,10,10);
        mTimeLeft->SetColors(0x40ffffff, oglTrRED);
        mTimeLeft->ShowPercentage(false);
        mTimeLeft->SetProgress(0.25 * 100);
        mTimeLeft->SetAlwaysDraw(mSearchTopic ? true : false);

        mTimeLeftText = new StaticText(mTimeLeft, 0, 0, tLeftW, 26, "10:00");
    }

    void BuildSearchTopicGui(int nrImOnRow)
    {
        mSearchTopicGui = 0;
        if (!mSearchTopic) return;

        OglGui::Window* tab = mTabs->CreateTab("F1: Topics", -1, TAB_TOPIC);
        mSearchTopicGui = new SearchTopicGui(tab, tab->W(), tab->H(), nrImOnRow,
                                             mThumbWidth, mThumbHeight,
                                             mViewScale, mSearchTopic,
                                             mLogoIm, mLogoAnim);
        mSearchTopicGui->SetTopicListener(this, 0);
    }

    void BuildQueryGui()
    {
        mQueryGui = 0;
        if (mDisableQueryTab) return;

        OglGui::Window* parent = mWnd2;
        if (!mWnd2 || (mUseWnd2 != String("Query")))
            parent = mTabs->CreateTab("F2: Query", -1, TAB_QUERY); 

        mQueryGui = new QueryGui(parent, parent->W(), parent->H(), mThumbWidth,
                                 mThumbHeight, mViewScale, mThreadSet,
                                 mProgramNames, TAB_QUERY);
        mQueryGui->AddConcepts(mConceptCatName, mConceptQualityName,
                               mConceptMappingName, mConceptRanking );
        mQueryGui->SetQueryGuiListener(this);
        mQueryGui->SetAutomaticResultsDir(mAutomaticResultsDir);
#ifdef OGL_USING_GLUT
        mQueryGui->SetAlwaysDraw(parent == mWnd2);
#endif
        AppController::Instance().AddControl((QueryGui*) mQueryGui);
    }

    void BuildRotorBrowserGui()
    {
        OglGui::Window* tab = mTabs->CreateTab("F3: Browse", -1, TAB_MDBROWSER);
        mBrowserGui = new RotorBrowserGUI(tab, tab->W(), tab->H(),
                                          mThreadSet, mSegDoc, mThumbWidth,
                                          mThumbHeight, mViewScale,
                                          TAB_MDBROWSER, true, mShowMinimap);

        //mBrowserGui->ScaleChildren();
        //mBrowserGui->ConnectTo(tab, ALLSIDES);
        mBrowserGui->AddRotorBrowserListener(this);
        mBrowserGui->SetProgramNames(mProgramNames);
        AppController::Instance().AddControl((RotorBrowserGUI*) mBrowserGui);
        if (mQueryGui)
            mQueryGui->SetRotorBrowserListener(mBrowserGui);
    }

    void BuildSortGui()
    {
        OglGui::Window* tab = mTabs->CreateTab("F4: Sort", -1, TAB_SORT);
        mSortGui = new SortGui(tab, tab->W(), tab->H(), mThumbWidth,
                               mThumbHeight, mViewScale, mThreadSet, TAB_SORT);
        AppController::Instance().AddControl((SortGui*)mSortGui);
        mSortGui->SetSortGuiListener(this);
    }

    void BuildSortNegativeGui()
    {
        OglGui::Window* tab =
            mTabs->CreateTab("Negative", -1, TAB_SORT_NEGATIVE);
        mSortGui = new SortGui(tab, tab->W(), tab->H(), mThumbWidth, mThumbHeight,
                               mViewScale, mThreadSet, TAB_SORT_NEGATIVE,
                               "bookmarked_negative");
        AppController::Instance().AddControl((SortGui*)mSortGui);
        mSortGui->SetSortGuiListener(this);
    }

    void BuildThreadSetGui(int nrImOnRow)
    {
        OglGui::Window* tab = mTabs->CreateTab("Threads", -1, TAB_THREAD);
        mThreadSetGui = new ThreadSetGui(tab, tab->W(), tab->H(), nrImOnRow,
                                         mThumbWidth, mThumbHeight, mViewScale,
                                         mThreadSet, mSegDoc, TAB_THREAD);
        AppController::Instance().AddControl((ThreadSetGui*)mThreadSetGui);

    }

    void BuildGrid(int nrImOnRow)
    {
        OglGui::Window* tab = mTabs->CreateTab("Grid", -1, TAB_GRID);
        mSegDocMainGrid =
            new SegmentationDocumentGuiMain(tab, tab->W(), tab->H(), nrImOnRow,
                                            mThumbWidth, mThumbHeight,
                                            mViewScale, mShowAnno, mSegDoc,
                                            mLogoIm, mLogoAnim, TAB_GRID);
        AppController::Instance().AddControl((AppControlDoc*) mSegDocMainGrid);
    }

#if 0
    void BuildDetails()
    {
        if (mUseWnd2 == String("Details"))
        {
            mDetailWindow = new ShotDetailWindow(mWnd2, W(), H(), mThumbWidth,
                                                 mThumbHeight, mThreadSet,
                                                 mSegDoc);
            mSegDocMainGrid->AddDocListener(mDetailWindow);
            mDetailWindow->SetAlwaysDraw(true);
            oglSys.SetAlwaysDraw(mDetailWindow->GetOGLWND(), 1);
        }
        else
        {
            mDetailWindow = 0;
            /*          
            tab = mTabs->CreateTab("Details", -1, TAB_DETAILS);
            mDetailWindow =
                new ShotDetailWindow(tab,wndW,wndH,mThumbWidth,
                                     mThumbHeight,mThreadSet,mSegDoc);
            mDetailWindow->SetControlId(TAB_DETAILS);
            AppController::Instance().AddControl(mDetailWindow);
            */
        }
    }
#endif

    void BuildDetails()
    {
        mDetailWindow = 0;
        if (mDisableDetailsTab) return;

        OglGui::Window* wnd = mWnd2;
        if (!mWnd2 || (mUseWnd2 != String("Details")))
            wnd = mTabs->CreateTab("Details", -1, TAB_DETAILS);

        mDetailWindow = new ShotDetailWindow(wnd,wnd->W(),wnd->H(),mThumbWidth,
                                             mThumbHeight, mThreadSet, mSegDoc);

// RvB: Slows browsing to much
//        mSegDocMainGrid->AddDocListener(mDetailWindow);

        if (mWnd2 != wnd)
        {
            mDetailWindow->SetControlId(TAB_DETAILS);
            AppController::Instance().AddControl(mDetailWindow);
        }
#ifdef OGL_USING_GLUT
        else
            mDetailWindow->SetAlwaysDraw(true);
#endif
    }

    void BuildStills(int nrImOnRow)
    {
        mSegDocStills = 0;
        if (mDisableStillsTab || !mSegDoc->GetImSetStills()) return;

        OglGui::Window* wnd = mWnd2;
        if (!mWnd2 || (mUseWnd2 != String("Stills")))
            wnd = mTabs->CreateTab("Stills", -1, TAB_STILLS);

        mSegDocStills =
                new SegmentationDocumentGuiStills(wnd, wnd->W(), wnd->H(),
                                                  nrImOnRow, mThumbWidth,
                                                  mThumbHeight, mViewScale,
                                                  true, mImageStills,
                                                  mSegDoc, TAB_STILLS);
        mSegDocMainGrid->AddDocListener(mSegDocStills);

        // RvB: Explanation: To react to global keys ('u') when used as tab
        if (wnd != mWnd2)
            AppController::Instance().AddControl((AppControlDoc*)mSegDocStills);
#ifdef OGL_USING_GLUT
        mSegDocStills->SetAlwaysDraw(mWnd2==wnd);
#endif
        ILOG_DEBUG("BuildGUI: Stills " << (mWnd2==wnd ? "window" : "tab") <<
                   " enabled.");
    }

    void BuildSearchJudgeGui(int nrImOnRow)
    {
        if (!mJudge) return;

        OglGui::Window* tab = mTabs->CreateTab("Judge", -1, TAB_JUDGE);
        mSearchJudgeGui = new SearchJudgeGui(tab, tab->W(), tab->H(), nrImOnRow,
                                             mThumbWidth, mThumbHeight,
                                             mViewScale, "bookmarked",
                                             "retrieved", mJudge, mTrecTopic,
                                             mShots, mKeyframes,
                                             mSegDoc->GetImSetKeyframes(true));
    }

    void BuildHelpGui()
    {
        OglGui::Window* tab = mTabs->CreateTab("Help", -1, TAB_HELP);
        mHelpGui = new HelpViewer(tab, tab->W(), tab->H());
    }

    void StripConceptNames()
    {
        CmdOptions& options = CmdOptions::GetInstance();
        int stripToDot = options.GetInt("conceptStripToDot");
        for (int i=0 ; i<mConceptRanking->NrTables() ; i++)
        {
            Util::StringParser p(mConceptRanking->GetName(i));
            char upToChar = '.';
            p.Advance(upToChar, stripToDot);
            String res = p.GetString('.', false);
            mConceptRanking->Rename(i, res);
        }
        if (options.GetInt("conceptStripExtension"))
        {
            for (int i=0 ; i<mConceptRanking->NrTables() ; i++)
            {
                String name = mConceptRanking->GetName(i);
                int pos = name.find("-",0);
                if (pos == String::npos)
                    continue;
                String result = name.substr(0, pos);
//                pos = result.find("_",0); 
                // assumption: if extension then first part is nummeral
//                result = "*" + result.substr(pos+1);  
                mConceptRanking->Rename(i, result);
            }
        }
    }

    void SetBg(ULONG bg)
    {
        SetBackground(bg);
        if (mWnd2)
            mWnd2->SetBackground(bg);
    }

    void DoTwoMinutesTimeAlert()
    {
#ifndef OGL_USING_GLUT
        char buf[200];
        sprintf(buf,"%s\n%s",
                "You have less than two minutes left for this topic.",
                "Don't forget to sort the result :-)");
        oglSys.ErrorBox("Warning",buf);
#endif
        ILOG_WARN("2 minutes remaining for current topic");
        mDidTimeAlert = true;
    }


    void UpdateProgress()
    {
        // For Cees' active learning un-comment line below
        //return;
        if (!mSearchTopic)
            return;

        if (!mTimeLeft) return;

        double elapsed  = mSearchTopic->GetElapsedTime();

        if ((elapsed > 8) && (!mDidTimeAlert))
            DoTwoMinutesTimeAlert();

        // bg now: 0xff555566
        if (mTopicRunning)
        {
            if (elapsed > 7 && elapsed < 8)
            {
                double d  = (elapsed - 7);
                SetBg(oglSys.RGB2Color(0x55+0x20*d, 0x55-0x10*d, 0x66));
            }
            else if (elapsed > 8 && elapsed < 9.8)
            {
                double d = 1.0 - ((elapsed - 8) / 1.8);
                SetBg(oglSys.RGB2Color(0x75+0x10*d, 0x45, 0x66-0x10*d));
                SetInterval(0.2);
            }
            else if (elapsed > 9.8 && elapsed < 10.0)
            {
                double d = ((elapsed - 9.8) / 0.2);
                SetBg(oglSys.RGB2Color(0x85+0x7A*d, 0x45+0xBA*d, 0x55+0xAA*d));
                SetInterval(0.1);
            }
            else if (elapsed > 10)
            {
                SetBg(0xffffffff);
                SetInterval(0.5);
                elapsed = 15;
            }
        }
        elapsed         = 10.0 - elapsed;
        int minutes     = (int) elapsed;
        int seconds     = (int) ((elapsed - minutes) * 60);
        String timeleft = MakeString(minutes) + ":" + MakeString(seconds);

        if (mTimeLeft) {
            mTimeLeftText->SetText(timeleft);
            mTimeLeft->SetProgress(elapsed * 100.0 / 10.0);
        }
    }

    bool ComputeFinalResult()
    {
        ILOG_SYSTEM("computing final result set.");

        std::list<Core::Trec::ShotResult> finalresult;

        std::map<int,bool> nodups;

        int rank = 1;
        for (int i=0 ; i<mSegDoc->GetBookmarked()->Size() ; i++)
        {
            Core::Trec::ShotResult r;
            r.shotid = mSegDoc->GetBookmarked()->Get1(i);
            r.rank = rank++;
            nodups[r.shotid] = true;
            finalresult.push_back(r);
        }

        ILOG_INFO( rank-1 << " bookmarked shots added to final result set.");

        int startsuprank   = rank;
        int duplicates     = 0;
        int dropped        = 0;
        Thread* supplement = mThreadSet->GetThreadByName("shots_supplement");
        Thread* negatives  = mThreadSet->GetThreadByName("bookmarked_negative");

        if (supplement == NULL)
        {
            ILOG_WARN("no supplement thread set! Only " << 
                      finalresult.size() << " shots will be submitted!");
        }
        else
        {
            int firstshot = supplement->GetFirstShot();
            for (int i=0; i < supplement->GetLength(); i++)
            {
                Core::Trec::ShotResult r;
                r.shotid = supplement->GetShotAt(firstshot, i);
                if (nodups.find(r.shotid) == nodups.end())
                {
                    if (negatives && negatives->GetShotPosition(r.shotid) >= 0)
                        dropped++;
                    else
                    {
                        r.rank = rank++;
                        finalresult.push_back(r);
                    }
                }
                else duplicates++;
            }
        }
        char* str = " supplement shots added to final result set.";
        ILOG_INFO(rank - startsuprank << str);
        ILOG_INFO(duplicates << " duplicates in supplement shot set ignored.");
        str = " shots dropped from supplement because of negative annotation.";
        ILOG_INFO(dropped << str);

        ILOG_INFO(finalresult.size() << " shots before dumping TV09 dropped movies.");
        std::list<Core::Trec::ShotResult>  out;
        for (std::list<Core::Trec::ShotResult>::iterator i=finalresult.begin();i!=finalresult.end();i++)
            switch (mThreadSet->GetSegmentation()->GetVideoId((*i).shotid))
            {
                case 22:  // shot23_*
                case 158: // shot159_*
                case 187: // shot188_*
                case 198: // shot199_*
                case 407: // shot488_*
                case 514: // shot595_*
                case 543: // shot624_*
                    continue;
                default:
                    out.push_back(*i);
            }           
        ILOG_INFO(out.size() << " shots in final result set.");
        mThreadSet->AddThreadShots("finalresult", out);
                return true;
    }

    // load/save results

    bool SaveFinalResult()
    {
        ILOG_ENDACTION("topic");
        mTopicRunning = false;
        ILOG_SYSTEM("saving results for topic.");
        if (!mSearchTopic)
            return false;
        String curTopic = mSearchTopic->GetCurTopicNum();
        String fileName = String(".") + "/topic_" + curTopic + ".xml";
        String logfile = String(".") + "/log_" + curTopic + ".log";
        File f(fileName, "w");
        if (!f.Valid())
        {
            oglSys.ErrorBox("Error", "Unable to write result in current dir");
            return false;
        }
        fprintf(f.Fp(),"<videoSearchTopicResult tNum=\"%s\" ",curTopic.c_str());
        fprintf(f.Fp(),"elapsedTime=\"%.2f\" ",mSearchTopic->GetElapsedTime());
        fprintf(f.Fp(),"searcherId=\"user\">\n");

        Thread *result = mThreadSet->GetThreadByName("shots_finalresult");
        if (result == NULL)
        {
            ILOG_ERROR("final result set does not exist. Aborted save!");
            return false;
        }
        int first  = result->GetFirstShot();
        int length = result->GetLength();
        // For Cees' active learning comment line below
                if (length > 1000) length = 1000; // max 1000 results.

        fprintf(f.Fp(), "<!-- nr selected images = %d -->\n",
                mSegDoc->GetBookmarked()->Size());
        for (int i=0 ; i<length; i++)
        {
            String shot = mShots->GetName(result->GetShotAt(first, i));
            fprintf(f.Fp(), "<item seqNum=\"%d\" shotId=\"%s\"/>\n",
                    i+1, shot.c_str());
        }
        fprintf(f.Fp(), "</videoSearchTopicResult>\n\n");
        f.Close();
        SetBg(mBackgroundColor);
        ILOG_INFO("results for topic " << curTopic << " have been saved.");
        //ActionLogger::ClosePartLog(logfile);
        return true;
    }

    bool        mFilterLanguage;
    bool        mUseVisualRect;
    bool        mShowAnno;
    bool        mUseCross;
    bool        mImageStills;
    bool        mDisableQueryTab;
    bool        mDisableStillsTab;
    bool        mDisableDetailsTab;
    bool        mJudgeInBrowser;
    bool        mLoadWeibull;
    bool        mShowMinimap;
    bool        mLogoAnim;
    bool        mDidTimeAlert;
    bool        mTopicRunning;

    int         mYear;
    int         mWeibullScales;
    int         mNrWeibullLevels;
    int         mThumbWidth;
    int         mThumbHeight;
    int         mInitialBrowser;
    int         mBackgroundColor;

    double      mViewScale;

    String      mSearchTopicImages;
    String      mSearchTopicThumbnails;
    String      mAutomaticResultsDir;
    String      mKeyServer;
    String      mUseWnd2;
    String      mVideoSetName;
    String      mImageSetName;
    String      mConceptSetName;
    String      mConceptCatName;
    String      mConceptQualityName;
    String      mConceptMappingName;
    String      mQbyExampleSet;
    String      mTrecTopicSetName;
    String      mJudgeFileName;
    String      mConceptModel;
    String      mConceptFeature;

    ProgramNameReader*                      mProgramNames;
    SimilarityTableSet*                     mConceptRanking;
    SimilarityTableSet*                     mThreadRanking;
    SimilarityTableSet*                     mQbyExampleRanking;
    Core::VideoSet::VideoSet*               mVidSet;
    Core::VideoSet::SegmentationDocument*   mSegDoc; // controls current shot
    Core::VideoSet::Segmentation*           mShots;
    Core::VideoSet::Keyframes*              mKeyframes;
    Core::Trec::TrecTopic*                  mTrecTopic;
    Core::Trec::SearchTopic*                mSearchTopic;
    Core::Trec::SearchJudge*                mJudge;
    Core::Trec::ThreadSet*                  mThreadSet;
    Core::Array::Array2dVec3UInt8*          mLogoIm;

    // GUI
    Visualization::Window*                  mWnd2;
    OglGui::Tabs*                           mTabs;
    HelpViewer*                             mHelpGui;
    SearchTopicGui*                         mSearchTopicGui;
    SearchJudgeGui*                         mSearchJudgeGui;
    ThreadSetGui*                           mThreadSetGui;
    QueryGui*                               mQueryGui;
    SortGui*                                mSortGui;
    RotorBrowserGUI*                        mBrowserGui;
    SegmentationDocumentGuiMain*            mSegDocMainGrid;
    SegmentationDocumentGuiStills*          mSegDocStills;
    ShotDetailWindow*                       mDetailWindow;
    ProgressBar*                            mTimeLeft;
    StaticText*                             mTimeLeftText;
 
    Application::Videolympics::VideolympicsClient *mVideolympicsClient;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(WindowTrecSearch, Application);

int
mainTrecSearch(int argc, char* argv[])
{
    OglInit(&argc, &argv[0]);

    CmdOptions& options = CmdOptions::GetInstance();
    options.Initialise(true, false, true);
    options.SetDefault("wndWidth", "1280");
    options.SetDefault("wndHeight", "975");

    char* extInfo = "tab to be placed on 2nd screen: Query, Details or Stills";
    options.AddOption(0, "useWnd2", extInfo, "Details");
    options.AddOption(0, "small", "", "0");
    options.AddOption(0, "noArchive", "", "0");
    options.AddOption(0, "imFileArchive", "", "0");
    options.AddOption(0, "imServer", "name", "");
    options.AddOption(0, "nrWeibullScales", "", "1");
    options.AddOption(0, "nrWeibullLevels", "", "3");
    options.AddOption(0, "noLoadWeibull", "", "0");
    options.AddOption(0, "maxImagesOnRow", "", "99");
    options.AddOption(0, "wndBg", "", "OglGuiBg");

//    options.AddOption(0, "minimap", "filename to write minimap to", "");
//    options.AddOption(0, "minimapdepth", "depth of minimap", "25");

    options.AddOption(0, "judgeInBrowser", "", "0");

    options.AddOption(0, "actionloglevel", "0=all .. 10=nothing", "2");
    options.AddOption(0, "actionlog", "filename", "trecsearch.log");
    options.AddOption(0, "actionlogtofile", "0 = no, 1 = yes", "1");

    extInfo = "1=CrossBrowser, 2=RotorBrowser, 3=ForkBrowser";
    options.AddOption(0, "initialbrowser", extInfo, "1");
    options.AddOption(0, "enableMinimap", "", "0");

    extInfo = "0=no, thumbnails, 1=yes, only center, 2=yes, always";
    options.AddOption(0, "mdBrowserUseKeyframes", extInfo, "0");
    options.AddOption(0, "mdBrowserAspectRatio", "0=automatic, else value","0");

    extInfo = "nr of shots from center, 0=only center";
    options.AddOption(0, "mdBrowserHighResDistance", extInfo, "0");

    extInfo = "hostname of VideOlympics contest server";
    options.AddOption(0, "videolympicsServer", extInfo, "");

    extInfo = "port of VideOlympics contest server";
    options.AddOption(0, "videolympicsPort", extInfo, "");
    options.AddOption(0, "videolympicsTeam", "VideOlympics team nr.", "");

    if (!options.ParseArgs(argc, argv, "", 0))
        return 1;

    int reqWndWidth  = options.GetInt("wndWidth");
    int reqWndHeight = options.GetInt("wndHeight");
    if (options.GetBool("small"))
    {
        reqWndWidth  = 1020;
        reqWndHeight = 740;
    }

    std::cout << "starting WindowTrecSearch..." << std::endl;
    WindowTrecSearch* oglWnd = new WindowTrecSearch(reqWndWidth, reqWndHeight);
    if (!oglWnd->Valid())
    {
        std::cout << "WINDOWTRECSEARCH FAILED." << std::endl;
        return 0;
    }
    Visualization::AppController::Instance().MainLoop();

    return 1;
}

} // namespace Application
} // namespace Impala

int
main(int argc, char* argv[])
{
    return Impala::Application::mainTrecSearch(argc, argv);
}

---