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

---

MediaTable.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef MediaTable_h
#define MediaTable_h

typedef unsigned int uint;

#define MEDIATABLE_USING_IMAGEDIR
#define MEDIATABLE_USING_CSV
#define MEDIATABLE_USING_COMBINEDVIEWS
//#define MEDIATABLE_USING_FLICKR
#define USE_CURL
//#define USE_BOOST_THREAD
#define USE_BOOST_THREADPOOL

// Currently not supported:
//#define MEDIATABLE_USING_MULTIPLE_VIEWS
//#define MEDIATABLE_USING_SQLITE

#ifdef MEDIATABLE_BASIC
#define MEDIATABLE_USING_CSV
#undef MEDIATABLE_USING_IMAGEDIR
#undef MEDIATABLE_USING_COMBINEDVIEWS
#undef MEDIATABLE_USING_FLICKR
#endif

#ifdef MEDIATABLE_VIDEOLYMPICS
#undef MEDIATABLE_USING_CSV
#undef MEDIATABLE_USING_IMAGEDIR
#undef MEDIATABLE_USING_COMBINEDVIEWS
#undef MEDIATABLE_USING_FLICKR
#define MEDIATABLE_USING_TREC
#undef USE_CURL
#define BOOST_THREADPOOL_SIZE 1
#endif

#ifdef RICHARD
//#define MEDIATABLE_USING_IMAGEDIR
#define MEDIATABLE_USING_TREC
#undef MEDIATABLE_BASIC
#undef MEDIATABLE_USING_CSV
#undef MEDIATABLE_USING_COMBINEDVIEWS
#undef MEDIATABLE_USING_FLICKR
#undef USE_BOOST_THREAD
#undef USE_BOOST_THREADPOOL
#define BOOST_THREADPOOL_SIZE 8
#undef OGL_USING_GLUT
#endif

#include "Basis/CmdOptions.h"

#include "OglGui/OglLib.cpp"
#include "OglGui/Tabs.h"

#include "Modules/ModuleStore.h"

#include "Modules/TableDataSourceModule.h"
#include "Modules/VisualizationModule.h"
#include "OglGui/Button.h"
#include "OglGui/TitledWindow.h"
#include "OglGui/GroupBox.h"
#include "OglGui/DropDownStringSelector.h"

#ifdef MEDIATABLE_USING_IMAGEDIR
#include "Modules/ImageDirModule.h"
#endif
#ifdef MEDIATABLE_USING_CSV
#include "Modules/CSVModule.h"
#endif
#ifdef MEDIATABLE_USING_FLICKR
#include "Modules/FlickrModule.h"
#endif
#ifdef MEDIATABLE_USING_COMBINEDVIEWS
#include "Modules/CombinedViewsModule.h"
#endif
#ifdef MEDIATABLE_USING_TREC
#include "TableDataSourceTrec.h"
#endif

#ifndef MEDIATABLE_VIDEOLYMPICS
#include "Modules/BarPlotModule.h"
#include "Modules/TimeLineModule.h"
#endif

#include "Modules/ViewerPointCloudModule.h"

// Currently not supported:
//#include "Modules/MapModule.h"
//#include "Modules/GraphModule.h"
#include "Modules/RandomImageModule.h"

#include "TableDataStore.h"

#include "GridWindow.h"
#include "SelectionCollection.h"
#include "TableWindow.h"
#include "TableControlBarWindow.h"
#include "TableOverviewWindow.h"

#include "ImageLoader.h"
#include "OglImageCacheStore.h"

namespace Impala {
namespace Application {
namespace MediaTable {

class MediaTable: public OglGui::Window, public OglGui::ButtonListener,
                                  public OglGui::StringListener, public TableDataStoreListener,
                                  public OglGui::CloseWindowListener, public OglGui::GetOglImageByIdInterface,
                                  public VisualizationModuleListener, public TableDataSourceModuleListener,
                  public OglGui::TabsListener
{
    typedef OglGui::Window                      Window;
    typedef OglGui::TitledWindow                TitledWindow;
    typedef OglGui::GroupBox                    GroupBox;
    typedef OglGui::Button                      Button;
    typedef OglGui::Tabs                                                Tabs;
    typedef OglGui::StringSelector                              StringSelector;

public:
        MediaTable(int w, int h) : Window(0, 0, w, h)
    {
        Impala::CmdOptions& options = Impala::CmdOptions::GetInstance();

        ILOG_STARTACTION("building GUI", ILOG_LEVEL_INFO);
        Init(w,h);
        ILOG_ENDACTION("building GUI");

        GetOGLWND()->topTitle = "MediaTable";
    }

    void Go()
    {
        Start();
        OglEventLoop();
    }

    virtual void KeyboardFunc(int c, int state)
    {
        if (mTable->GetVisible())
            mTable->KeyboardFunc(c, state);
        if (mGrid->GetVisible())
            mGrid->KeyboardFunc(c, state);
        // ToDo: Forward Keyboard to active tab
        Window::KeyboardFunc(c, state);
    }

    void Init(int w, int h)
    {
        /* quick parsing of options, to be redone later */
        Impala::CmdOptions& options = Impala::CmdOptions::GetInstance();

        //ULONG bgCol  = 0xffd2c799;
        ULONG bgCol  = oglGUI_BG;
        String bgStr = options.GetString("wndBg");
        if (!bgStr.empty())
            bgCol = OglColorStr(bgStr.c_str());
        SetBackground(bgCol);

        TableDataSource *src = 0;

#ifdef MEDIATABLE_BASIC
                ILOG_INFO("loading data.csv...");
        src = new TableDataSourceCSV("data.csv");
        if(!src->GetTotalRows())
        {
                ILOG_ERROR("data.csv could not be opened");
                exit(0);
        }
                ILOG_INFO("..done. " << src->GetTotalRows() << " rows loaded.");
#else
#ifdef MEDIATABLE_USING_SQLITE
        if (options.GetString("database") != "")
            src = new TableDataSourceSqliteDb(options.GetString("database"));
#endif
#ifdef MEDIATABLE_USING_IMAGEDIR
        if (options.GetString("directory") != "")
            src = new TableDataSourceImageDir(options.GetString("directory"));
#endif
#ifdef MEDIATABLE_USING_TREC
        if (options.GetBool("trec"))
                        src = new TableDataSourceTrec();
#endif

#ifdef MEDIATABLE_USING_CSV
        if (options.GetString("csv") != "" && !src)
            src = new TableDataSourceCSV(options.GetString("csv"));
        if (options.GetString("csv") != "" && src)
                {
                        TableDataSource *src1 = src;
                        TableDataSource *src2 = new TableDataSourceCSV(options.GetString("csv"));
                        TableDataView *view1 = new TableDataView(src1);
                        TableDataView *view2 = new TableDataView(src2);

                        TableDataSourceCombinedViews *csrc = new TableDataSourceCombinedViews();
                        csrc->AddTableDataView(view1, "filename");
                        csrc->AddTableDataView(view2, "filename");
                        src = csrc;
                }
#endif

#ifdef MEDIATABLE_USING_FLICKR
        if(!src)
                src = new TableDataSourceFlickrPhotoList();
#endif
        if (!src)
        {
            ILOG_ERROR("Please start with either -a <db>, -d <directory> " <<
                       "or --trec --ini <inifile>");
            return;
        }
#endif

        TableDataStore *store = TableDataStore::GetInstance();
        store->AddTableDataSource("Default", src);
        TableDataView *view = store->GetTableDataView("Default", "Default");

        mImageLoader = new ImageLoader(this);

        int csize = options.GetInt("imageCacheSize");
        csize = (csize > 100) ? csize : 100;
        OglImageCacheStore::Initialize(csize);

        if (options.GetBool("preload"))
        {
                        std::string column = "";
                        std::vector<TableColumn*>::iterator it;
                        std::vector<TableColumn*>                       columns;
                        columns = view->GetColumns(true, true);
                        for(it = columns.begin(); it != columns.end(); it++)
                        {
                                if((*it)->GetType() && TableDataSource::TYPE_FLAG_IMAGE)
                                {
                                        column = (*it)->GetName();
                                        break;
                                }
                        }
                        if(column != "")
                        {
                                int maxPreload = csize;
                                if(view->GetTotalRows() < maxPreload)
                                        maxPreload = view->GetTotalRows();
                                ILOG_INFO("Pre-filling cache with " << maxPreload << " images.");
                                for(int i = 0; i < maxPreload; i++)
                                {
                                        if(i%100 == 0 && i != 0)
                                        {
                                                ILOG_DEBUG("Preloading images until " << i << " of " << maxPreload);
                                                mImageLoader->WaitUntilDone();
                                        }
                                        long long id = view->GetSortedQuid(column, i);
                                        OGLIMAGE* im = mImageLoader->GetOglImageById(id);
                                        OglImageCacheStore::GetInstance()->Add(im, id);
                                }
                                mImageLoader->WaitUntilDone();
                        }
        }

        int btnH = 32;
        int botH = 124;
        int centerH = h - 10 - btnH - botH;

#ifdef MEDIATABLE_USING_MULTIPLE_VIEWS
#ifdef IMAGEDIRMODULE_H
        ModuleStore::GetInstance()->Register(new ImageDirModule());
#endif
#ifdef CSVMODULE_H
        ModuleStore::GetInstance()->Register(new CSVModule());
#endif
#ifdef FLICKRMODULE_H
        ModuleStore::GetInstance()->Register(new FlickrModule());
#endif
#ifdef COMBINEDVIEWSMODULE_H
        ModuleStore::GetInstance()->Register(new CombinedViewsModule());
#endif
#endif

                VisualizationModule* m;
#ifdef BARPLOTMODULE_H_
                m = new BarPlotModule();
                m->SetGetOglImageByIdInterface(mImageLoader);
        ModuleStore::GetInstance()->Register(m);
#endif
#ifdef MAPMODULE_H_
                m = new MapModule();
                m->SetGetOglImageByIdInterface(mImageLoader);
        ModuleStore::GetInstance()->Register(m);
#endif
#ifdef GRAPHMODULE_H_
                m = new GraphModule();
                m->SetGetOglImageByIdInterface(mImageLoader);
        ModuleStore::GetInstance()->Register(m);
#endif
#ifdef VIEWERPOINTCLOUDMODULE_H_
                m = new ViewerPointCloudModule();
                m->SetGetOglImageByIdInterface(mImageLoader);
        ModuleStore::GetInstance()->Register(m);
#endif
#ifdef TIMELINEMODULE_H_
                m = new TimeLineModule();
                m->SetGetOglImageByIdInterface(mImageLoader);
        ModuleStore::GetInstance()->Register(m);
#endif
#ifdef RANDOMIMAGEMODULE_H_
                m = new RandomImageModule();
                m->SetGetOglImageByIdInterface(mImageLoader);
        ModuleStore::GetInstance()->Register(m);
#endif
                
        ModuleStore::GetInstance()->RegisterListener(static_cast<VisualizationModuleListener*>(this));
        ModuleStore::GetInstance()->RegisterListener(static_cast<TableDataSourceModuleListener*>(this));

        ModuleStore::ModuleMapType vModules =
            ModuleStore::GetInstance()->GetModulesOfType("VisualizationModule");
        ILOG_DEBUG("VisualizationModules = " << vModules.size());

        ModuleStore::ModuleMapType::iterator it;
        for (it=vModules.begin() ; it != vModules.end(); it++ )
        {
            ILOG_DEBUG("VisualizationModule:" << (*it).first << " => " <<
                       (*it).second);
        }

        mTabs = new OglGui::Tabs(this, 5, 5+botH, w-60, centerH+btnH, 120);
        mTabs->ConnectTo(this);

        OglGui::Window* wnd = mTabs->CreateTab("Table");
        TableWindow *table =
            new TableWindow(wnd, view, 0, 0, wnd->W(), wnd->H()-btnH);
        table->ConnectTo(wnd);

        TableControlBarWindow *buttonbar =
            new TableControlBarWindow(wnd, table, 0, table->H(), wnd->W(), btnH);
        buttonbar->ConnectTo(wnd, OglGui::TOLEFTRIGHT | OglGui::TOTOP);
        buttonbar->SetVisible(true);

        wnd = mTabs->CreateTab("Grid");
        GridWindow *grid = new GridWindow(wnd, view, 0, 0, wnd->W(), wnd->H());
        grid->ConnectTo(wnd);
        grid->SetGridSize(75, 75);

        if(ModuleStore::GetInstance()->CountModulesOfType("VisualizationModule") ||
                ModuleStore::GetInstance()->CountModulesOfType("TableDataSourceModule"))
        {
            Window* tabBar = mTabs->TabBar();
            Button* but    = new Button(tabBar, tabBar->W()-45, -2, 35, 26, "+");
            but->SetRoundness(200, 200, 2, 2);
            but->SetButtonListener(this);
            but->ConnectTo(tabBar, OglGui::TORIGHT);
        }

        mTabs->SetActiveTab(0);
        mTabs->SetTabsListener(this);

        mOverview =
            new TableOverviewWindow(this, view, w-55, 5+botH, 50, centerH);
        mOverview->ConnectTo(this, OglGui::TORIGHT|OglGui::TOTOPBOTTOM);
        mOverview->SetHeaderHeight(40);

        SelectionCollection *selcol =
            new SelectionCollection(this,view,5,5,w-10,botH);
                selcol->ScaleChildren();
                selcol->SetAllowScaling(false);
        selcol->ConnectTo(this, OglGui::TOLEFTRIGHT | OglGui::TOBOTTOM);

        // overlay window to show preview of table on top of everything else..
        // there must be a better way to do this though :)
        mOverlayWindow = new Window(this, 0, 0, w, h);
        mOverlayWindow->ConnectTo(this);
        oglSys.SetNoMouseInput(mOverlayWindow->GetOGLWND(), 1);

        grid->SetListenTableUpdates(false);
        table->SetListenTableUpdates(true);
        mOverview->SetListenTableUpdates(true);

        // add default data columns for specified data source:
        table->AddColumnsFromDataSource();
        grid->AddColumnsFromDataSource();

        table->SetGetOglImageByIdInterface(mImageLoader);
        grid->SetGetOglImageByIdInterface(mImageLoader);

        // for which column/cache should the table display larger images
        // OBS: (need to set here because there can be more than one images row)
        table->SetZoomViewTargetWindow(mOverlayWindow, true);
        grid->SetZoomViewTargetWindow(mOverlayWindow, true);

        mTable = table;
        mGrid = grid;

        // TODO: Remove this, needed to show bucket sizes at start.
                view->DoUpdateSelectionEvent();

#ifdef MEDIATABLE_USING_MULTIPLE_VIEWS
                DoTableDataStoreWindow(this, w-160+5, h-btnH+3, 150, centerH+btnH+8);
#endif

                //ScaleChildren();
    }

    virtual OGLIMAGE* GetOglImageById(long long quid)
    {
        return Visualization::RgbOglImage::OglImage
                (TableDataStore::GetInstance()->GetImageDataByQuid(quid));
    }

#ifdef MEDIATABLE_USING_MULTIPLE_VIEWS
        void DoTableDataStoreWindow(OglGui::Window* parent, int x, int y, int w, int h) {
                mTableDataStoreWindow = new OglGui::DropDownStringSelector(parent, x, y, w, "TableDataStore", w, h);
                mTableDataStoreWindow->ConnectTo(parent, OglGui::TORIGHT|OglGui::TOTOPBOTTOM);
                mTableDataStoreWindow->StrSelector()->ConnectTo(parent, OglGui::TORIGHT|OglGui::TOTOPBOTTOM);
                mTableDataStoreWindow->StrSelector()->SetBackground(parent->GetBackground());
                mTableDataStoreWindow->StrSelector()->SetStringListener(this);
                mTableDataStoreWindow->StrSelector()->AddString("TableDataStore is empty.");

        TableDataStore::GetInstance()->AddTableDataStoreListener(this);
        TableDataStore::GetInstance()->DoUpdateTableDataStoreEvent();
        }

    void StringSelectionEvent(StringSelector *src, int strIndex, void* listenerData) {
        ILOG_INFO("StringSelection: " << src->GetString(strIndex));
    }

    void UpdateTableDataStoreEvent() {
        mTableDataStoreWindow->StrSelector()->RemoveStrings();
        std::map<std::string, std::vector<std::string> > contents;
        contents = TableDataStore::GetInstance()->GetContents();
        for(std::map<std::string, std::vector<std::string> >::iterator it = contents.begin(); it != contents.end(); it++) {
                for(std::vector<std::string>::iterator itv = it->second.begin(); itv != it->second.end(); itv++) {
                        mTableDataStoreWindow->StrSelector()->AddString(it->first + ":" + *itv);
                }
                if(!it->second.size())
                        mTableDataStoreWindow->StrSelector()->AddString(it->first + ":Default");
        }
    }
#endif

    Window* GetConfigWindow()
    {
        mConfigWindow = new TitledWindow(mOverlayWindow, W()/2-260, H()/2-160,
                                         520, 320, "Add new tab",
                                         TitledWindow::BtnClose);
        mConfigWindow->SetBackground(this->GetBackground());
        mConfigWindow->SetRoundness(0, 0, 0 ,0);
        mConfigWindow->SetCloseWindowListener(this, 0);
        new OglGui::Strut(mConfigWindow, mConfigWindow->W(), 24);

        int h = mConfigWindow->H();
        GroupBox* grp;
        ModuleStore::ModuleMapType::iterator it;

#ifdef MEDIATABLE_USING_MULTIPLE_VIEWS
        h -= 160;
        grp = new GroupBox(mConfigWindow, mConfigWindow->W()-4, 160,
                                     "Data Sources:");
        new OglGui::Strut(grp, grp->W(), 16);

        ModuleStore::ModuleMapType tModules =
            ModuleStore::GetInstance()->GetModulesOfType("TableDataSourceModule");

        for (it=tModules.begin() ; it != tModules.end(); it++ )
            static_cast<TableDataSourceModule*>
            ((*it).second)->ContributeToConfigurationWindow(mOverlayWindow, grp);

        grp->RepositionViewports();
        grp->ScaleChildren();
#endif

        grp = new GroupBox(mConfigWindow, mConfigWindow->W()-4, h,
                           "Visualizations:");
        new OglGui::Strut(grp, grp->W(), 16);

        ModuleStore::ModuleMapType vModules =
            ModuleStore::GetInstance()->GetModulesOfType("VisualizationModule");

        for (it=vModules.begin() ; it != vModules.end(); it++ )
            static_cast<VisualizationModule*>
            ((*it).second)->ContributeToConfigurationWindow(mOverlayWindow, grp);

        grp->RepositionViewports();
        grp->ScaleChildren();

        mConfigWindow->RepositionViewports();
        mConfigWindow->ScaleChildren();

        mOverlayWindow->SetBackground(0xCC000000);
        oglSys.SetNoMouseInput(mOverlayWindow->GetOGLWND(),0);

#ifdef MEDIATABLE_VIDEOLYMPICS
                if(ModuleStore::GetInstance()->CountModulesOfType("VisualizationModule")  == 1 &&
                   ModuleStore::GetInstance()->CountModulesOfType("TableDataSourceModule") == 0)
                {
                        VisualizationModule *vm = 
                                static_cast<VisualizationModule*> ((*vModules.begin()).second);
                        vm->DrawConfigWindow();
                        vm->ClearConfigWindowValues();
                        vm->ModuleSelected();
                }
#endif

        return mOverlayWindow;
    }

    void ReleaseConfigWindow()
    {
        mOverlayWindow->SetBackground(0);
        oglSys.SetNoMouseInput(mOverlayWindow->GetOGLWND(),1);
    }

private:
    void ButtonSelectionEvent(Button *src, void *userData)
    {
                if(src->GetLabel() == "+")
        {
                        GetConfigWindow();
                        return;
                }
    }

    void
    TabSelectionEvent(Tabs *src, int tabNr, void* data)
    {
        switch (tabNr)
        {
            case 0:
                ILOG_USER("User switched to TABLE visualization");
                mOverview->SetHeaderHeight(40);
                mGrid->SetListenTableUpdates(false);
                                mGrid->SetShowPreview(false);
                mTable->SetListenTableUpdates(true);
                                mTable->GetTableDataView()->DoUpdateNumberOfRowsEvent();
                mTable->GetTableDataView()->DoUpdateScrollFromSourceEvent();
                break;
            case 1:
                ILOG_USER("User switched to GRID visualization");
                mOverview->SetHeaderHeight(0);
                mGrid->SetListenTableUpdates(true);
                                mTable->SetShowPreview(false);
                mTable->SetListenTableUpdates(false);
                                mGrid->GetTableDataView()->DoUpdateNumberOfRowsEvent();
                mGrid->GetTableDataView()->DoUpdateScrollFromSourceEvent();
                break;
            default:
                ILOG_USER("User switched to visualization at tab " << MakeString(src->GetActiveTab()));
                mOverview->SetHeaderHeight(40);
                mGrid->SetListenTableUpdates(false);
                mTable->SetListenTableUpdates(false);
                                mGrid->SetShowPreview(false);
                                mTable->SetShowPreview(false);
                break;
        }
    }

        bool OnCloseWindow(Window *src, void* userData)
    {
                ReleaseConfigWindow();
                return true;
        }

        static void ActivateLastTab(Tabs* tabs)
    {
                uint maxTabId = 0;
                if(tabs->GetActiveTab() == 0)
            tabs->ActivateNextTab();
                for(; tabs->GetActiveTab() != 0; tabs->ActivateNextTab())
            maxTabId = tabs->GetActiveTab();
                tabs->SetActiveTab(maxTabId);
        }

        void HandleNewWindow(VisualizationModule* module)
    {
        mGrid->SetListenTableUpdates(false);
        mTable->SetListenTableUpdates(false);
                Window* wnd = mTabs->CreateTab(module->GetNewWindowName());
                module->NewWindow(wnd);
                ActivateLastTab(mTabs);
        }

        void HandleNewTableDataSource(TableDataSourceModule* module)
        {
                module->NewTableDataSource();
        }

        ImageLoader*                                    mImageLoader;

    TableWindow*                                        mTable;
    GridWindow*                                         mGrid;
    TableOverviewWindow*            mOverview;
    Window*                                                     mOverlayWindow;
    TitledWindow*                                       mConfigWindow;
    OglGui::Tabs*                                       mTabs;
    OglGui::DropDownStringSelector* mTableDataStoreWindow;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(MediaTable, MediaTable);

} // namespace MediaTable
} // namespace Application
} // namespace Impala

#endif // MediaTable_h

---