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

---

SimilarityTimeLineVideo.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Show impala concept similarities on a timeLine connected to a video player.
// NOTE: - Only for fixed frame duration 40 ms: 25 fps.
//       - Only for 13 concepts. In future checkboxes in a scrollwnd
//         to allow for more concepts.
//       - Assumes that all similarityTablesSets have the same concepts
//         as the first one given.
//       
// Author: Richard van Balen
#ifndef Impala_Visualization_SimilarityTimeLineVideo_h
#define Impala_Visualization_SimilarityTimeLineVideo_h

#ifndef OglGui_TitledWindow_h
#include "OglGui/TitledWindow.h"
#endif

#ifndef OglGui_WindowDocScroller_h
#include "OglGui/WindowDocScroller.h"
#endif

#include "OglGui/CheckBoxValueBars.h"
#include "OglGui/TexturedViewAnimator.h"

#include "Visualization/SimilarityTimeLine.h"
#include "Visualization/VideoPlayerWithButtons.h"
#include "Core/Table/SimilarityTableSet.h"
#include "Core/Stream/RgbDataSrc.h"

namespace Impala {
namespace Visualization {

class SimilarityTimeLineVideo : public OglGui::Window,
                                public OglGui::CheckBoxListener,
                                public OglGui::ButtonListener,
                                public OglGui::ValueScrollBarListener,
                                //public OglGui::WindowListener,
                                public OglGui::CloseWindowListener,
                                public SimilarityTimeLineListener,
                                public VideoPlayerListener
{
public:
    typedef OglGui::Window                    Window;
    typedef OglGui::TitledWindow              TitledWindow;
    typedef OglGui::SizableWindow             SizableWindow;
    typedef OglGui::ScrollWnd                 ScrollWnd;
    typedef OglGui::StaticText                StaticText;
    typedef OglGui::Button                    Button;
    typedef OglGui::CheckBox                  CheckBox;
    typedef OglGui::CheckBoxValueBar          CheckBoxValueBar;
    typedef OglGui::CheckBoxValueBars         CheckBoxValueBars;
    typedef OglGui::ValueScrollBar            ValueScrollBar;
    typedef OglGui::WindowDocScroller         WindowDocScroller;
    typedef Core::Table::SimilarityTableSet   SimilarityTableSet;
    typedef SimilarityTableSet::SimTableType  SimTableType;
    typedef std::vector<float>                FloatVector;
    typedef std::vector<FloatVector*>         Averages;
    typedef Core::Stream::RgbDataSrc          RgbDataSrc;

    SimilarityTimeLineVideo(int x, int y, int w, int h,
                            SimilarityTableSet* simSet, int options=3):
        Window(x, y, w, h)
    {
        Init(w, h, options, simSet);
    }

    SimilarityTimeLineVideo(Window* parent, int w, int h,
                            SimilarityTableSet* simSet, int options=3):
        Window(parent, w, h)
    {
        Init(w, h, options, simSet);
    }

    SimilarityTimeLineVideo(Window* parent, int x, int y, int w, int h,
                            SimilarityTableSet* simSet, int options=3):
        Window(parent, x, y, w, h)
    {
        Init(w, h, options, simSet);
    }

    VideoPlayer*        Player()            { return mVideoPlayer; }
    SimilarityTimeLine* TimeLine()          { return mSimTimeLine; }
    CheckBoxValueBars*  ChBoxValueBars()
    {
        return mChBoxValBars;
    }
    TitledWindow*       TitledTimeLine()    { return mTitledTimeLine; }
    Window*             AxisThumb()         { return mAxisThumb; }

    void CenterNeedleOnPlay(bool mode)      { mCenterNeedleOnPlay = mode; }
    bool CenterNeedleOnPlay()               { return mCenterNeedleOnPlay; }

    void CenterNeedle(bool mode)            { mCenterNeedle = mode; }
    bool CenterNeedle()                     { return mCenterNeedle; }

    SimilarityTimeLine* TimeLineExtra(int idx)
    {
        if (idx>=0 && idx<mExtraTimeLines.size())
            return mExtraTimeLines[idx];
        return 0;
    }

    void OpenVideo(RgbDataSrc* rgbDataSrc, strconst videoName)
    {
        mVideoPlayer->OpenVideo(rgbDataSrc);
        if (rgbDataSrc)
        {
            ShowTitle(videoName);
            HandleNewVideo();
        }
    }

    void OpenVideo(std::string videoName, strconst videoType)
    {
        mVideoPlayer->OpenVideo(videoName, videoType);
        ShowTitle(videoName);
        if (!videoName.empty())
            HandleNewVideo();
    }

    void HandleNewVideo()
    {
        mVideoPlayer->Reset();
        HandleFrameSettings();
    }

    void HandleFrameSettings()
    {
        int nFrames = mVideoPlayer->LastFrame();
        int imW = mVideoPlayer->DataSrc()->FrameWidth();
        if (mSimTimeLine->ViewStripRgbSrc())
            imW = mSimTimeLine->ViewStripRgbSrc()->FrameWidth();
        mSimTimeLine->Current(0);
        mSimTimeLine->SetSpan(40*nFrames);
        mSimTimeLine->SetMinMaxDocWidth(160, nFrames*imW);

        mTimeLineRuler->SetSpan(40*nFrames);
        for (int t=0; t<mExtraTimeLines.size(); t++)
        {
            mExtraTimeLines[t]->Current(0);
            mExtraTimeLines[t]->SetSpan(40*nFrames);
            mExtraTimeLines[t]->SetMinMaxDocWidth(160, nFrames*imW);
        }
    }

    void SetSimilarityTableSet(SimilarityTableSet* simSet)
    {
        mSimSet = simSet;

ClearAverages();
int avgFrames = 12;
if (mAvgFramesVSB)
    avgFrames = mAvgFramesVSB->GetValue();
ComputeAverages(avgFrames);
        mSimTimeLine->SetSimilarityTableSet(simSet);
mSimTimeLine->SetAverages(&mAverages, &mMaxima, &mMeans);
        for (int t=0; t<mExtraTimeLines.size(); t++)
            mExtraTimeLines[t]->SetSimilarityTableSet(simSet);
    }

    void ClearAverages()
    {
        for (int i=0; i<mAverages.size(); i++)
            delete mAverages[i];
        mAverages.clear();
        mMaxima.clear();
        mMeans.clear();
    }

    Averages* GetAverages()
    {
        return &mAverages;
    }

    FloatVector* Means()
    {
        return &mMeans;
    }

    FloatVector* Maxima()
    {
        return &mMaxima;
    }

    void ComputeAverages(int nFrames)
    {
        if (!mSimSet)
            return;
        nFrames += (nFrames%2) ? 1 : 0;
        int nFramesDiv2 = nFrames/2;

        for (int i=0; i<mSimSet->NrTables(); i++)
        {
            FloatVector*  avgVector = new FloatVector;
            SimTableType* simTable  = mSimSet->GetSimTable(i);
            int           tableSize = mSimSet->TableSize();
            double        sum       = 0.f;

            for (int s=0; s<nFrames; s++)
            {
                sum += simTable->Get1(s);
                if (s<nFramesDiv2)
                    avgVector->push_back((float)(sum/(s+1)));
            }
            int sz = tableSize - nFramesDiv2;
            for (int j=nFramesDiv2; j<sz; j++)
            {
                sum += simTable->Get1(j+nFramesDiv2);
                sum -= simTable->Get1(j-nFramesDiv2);
                avgVector->push_back((float)(sum/nFrames));
            }

            mAverages.push_back(avgVector);

            // Find max and mean
            float max = 0.f, val;
            sum = 0;
            for (int m=nFramesDiv2; m<tableSize-nFramesDiv2; m++)
            {
                sum += (val = (*avgVector)[m]);
                if (val > max)
                    max = val;
            }
            float mean = (float) (sum/(tableSize-nFrames));
            mMeans.push_back(mean);
            mMaxima.push_back(max);
        }
    }

    void ShowTitle(strconst videoName)
    {
        if (!videoName.empty())
        {
            std::string name = FileNameTail(videoName);
            mTitledVideoPlayer->TitleText()->SetText(name);
        }
    }

    TitledWindow*
    ExtraTimeLine(Window* parent, int x, int y, int w, int h, strconst str)
    {
        TitledWindow* TWnd = new TitledWindow(parent, x, y, w, h, str,1);
        Window*       pane = TWnd->ContentPane();

        WindowDocScroller* docScroller =
            new WindowDocScroller(pane,0,0,pane->W(),pane->H(),1);
        docScroller->ConnectTo(pane);
        SimilarityTimeLine* simTL =
            new SimilarityTimeLine(docScroller,0,16,pane->W(),pane->H()-16,0);
        docScroller->SetDocWindow(simTL,simTL,true);
        simTL->SetListener(this, (void *) mVideoPlayer);
        simTL->ViewStripShow(false);
        simTL->SetBackground(mSimTimeLine->GetBackground());
        simTL->SetBorderType(mSimTimeLine->GetBorderType());
        simTL->SetBorderBackground(mSimTimeLine->GetBorderBackground());
        simTL->SetBorderFillShaded(mSimTimeLine->GetBorderFillShaded());
        simTL->SetNeedleColor(mSimTimeLine->GetNeedleColor());
        mExtraTimeLines.push_back(simTL);
        SetSimilarityTableSet(mSimSet);
        HandleFrameSettings();
        TWnd->SetCloseWindowListener(this,(void*)simTL);
        return TWnd;
    }

    virtual void DisplayFunc()
    {
        mTimeLineRuler->DocX(5);
        mTimeLineRuler->DocW(mTimeLineRuler->W()-10);
        if (mSimTimeLine->H() < mAxisThumb->Y() + 40)
            mAxisThumb->SetDimensions(RETAIN,mSimTimeLine->H()-40,RETAIN,RETAIN);
        if (mAxisThumb->Y() < 18)
            mAxisThumb->SetDimensions(RETAIN,18,RETAIN,RETAIN);
        mSimTimeLine->SetAxisY(mAxisThumb->Y()+10);
        SyncCheckBoxSimColors();
        if (mCenterNeedle)
        {
            HandleVisibility(mSimTimeLine);
            for (int i=0; i<mExtraTimeLines.size(); i++)
                HandleVisibility(mExtraTimeLines[i]);
        }
        Window::DisplayFunc();
    }

protected:

    void SyncCheckBoxSimColors()
    {
        if (!mSimSet || !mChBoxValBars)
            return;
        for (int i=0; i<mSimSet->NrTables(); i++)
        {
            mSimTimeLine->SetShowSim(i, false);
            mSimTimeLine->SetSimColor(i,0);
            for (int t=0; t<mExtraTimeLines.size(); t++)
            {
                mExtraTimeLines[t]->SetShowSim(i, false);
                mExtraTimeLines[t]->SetSimColor(i,0);
            }
        }
        for (int i=0; i<mChBoxValBars->NrOfItems(); i++)
        {
            CheckBoxValueBar* chBoxValB = mChBoxValBars->GetItem(i);
            std::string       name      = chBoxValB->Name();
            int               idx       = mSimSet->GetIndex(name);
            if (idx != -1)
            {
                mSimTimeLine->SetSimColor(idx,chBoxValB->Color());
                mSimTimeLine->SetShowSim(idx,chBoxValB->Selected());
                for (int t=0; t<mExtraTimeLines.size(); t++)
                {
                    mExtraTimeLines[t]->SetSimColor(idx,chBoxValB->Color());
                    mExtraTimeLines[t]->SetShowSim(idx,chBoxValB->Selected());
                }
            }
        }
    }

    void HandleFeedbackControls(int frameNr)
    {
        int     frameErr = mSimTimeLine->FrameError();
        char    buf[40];
        sprintf(buf, "fr: %d", frameNr+frameErr);
        mFrameNrTxt->SetText(buf);

        if (!mSimSet || !mOptions || !mChBoxValBars)
            return;

        for (int i=0; i<mChBoxValBars->NrOfItems(); i++)
        {
            CheckBoxValueBar* chBoxValB = mChBoxValBars->GetItem(i);
            std::string       name      = chBoxValB->Name();

            char buf[20];
            sprintf(buf,"");
            int barW = 4;
            int idx  = mSimSet->GetIndex(name);
            if (idx!=-1)
            {
                SimTableType* simTable = mSimSet->GetSimTable(idx);
                double sim = simTable->Get1(frameNr+frameErr);
                sprintf(buf, "%5.5f", sim);
                barW = 4+sim*(mChBoxValBars->W()-chBoxValB->ValueBar()->X()-6);

                ULONG col = 0;
                float maxim = mMaxima[idx];
                if (maxim>=0.2 && frameNr<(*mAverages[idx]).size()-1)
                {
                    double avgSim = (*mAverages[idx])[frameNr+frameErr];
                    if (mSimTimeLine->PassTest(avgSim,maxim,mMeans[idx]))
                    {
                        UCHAR a = avgSim/maxim * 255;
                        col = ARGB2COLOR(a,255,255,255);
                    }
                }
                chBoxValB->ValueText()->SetBackground(col);
            }
            chBoxValB->ValueStr(buf);
            chBoxValB->ValueBar()->SetDimensions(RETAIN,RETAIN,barW,RETAIN);

            sprintf(buf,"");
            if (idx!=-1)
                sprintf(buf, "%2.2f %2.2f", mMaxima[idx], mMeans[idx]);
            mStatistics[i]->SetText(buf);
        }
    }

    virtual void
    CurrentChanged(SimilarityTimeLine *src, long nVal, void* userData)
    {
        VideoPlayer* vP = (VideoPlayer*) userData;
        int nFrame = (int) floor((nVal / 40.)+0.5); // Finds nearest frame
        if (nFrame != vP->FrameNr())
            vP->GotoFrame(nFrame);
        else
        {   // Needed to only allow needle at center of frames
            mSimTimeLine->Current(nFrame*40);
            mTimeLineRuler->Current(nFrame*40);
            for (int i=0; i<mExtraTimeLines.size(); i++)
                mExtraTimeLines[i]->Current(nFrame*40);
        }
    }

    virtual void
    OnNewFrame(VideoPlayer *src, int frameNr, void* userData)
    {
        mTimeLineRuler->Current(frameNr*40);
        mSimTimeLine->Current(frameNr*40);
        HandleVisibility(mSimTimeLine);

        for (int i=0; i<mExtraTimeLines.size(); i++)
        {
            mExtraTimeLines[i]->Current(frameNr*40);
            HandleVisibility(mExtraTimeLines[i]);
        }
        HandleFeedbackControls(frameNr);
    }

    void HandleVisibility(SimilarityTimeLine* simTL)
    {
        if (!simTL->IsDragging() &&
            (mCenterNeedle || (mVideoPlayer->Playing() && mCenterNeedleOnPlay)))
            simTL->ShowCurrentAt(simTL->W()/2);
        else
            simTL->MakeCurrentVisible();
    }

    virtual bool OnCloseWindow(Window *src, void* userData)
    {
        SimilarityTimeLine* simTL = (SimilarityTimeLine*) userData;
        for (int i=0; i<mExtraTimeLines.size(); i++)
        {
            if (simTL == mExtraTimeLines[i])
            {
                mExtraTimeLines.erase(mExtraTimeLines.begin() + i);
                return true;
            }
        }
        return true;
    }

    virtual void
    CheckBoxEvent(CheckBox *src, bool checked, void* userData)
    {
        if (src == mShowClassifyCB)
            mSimTimeLine->ShowClassify(checked);
        else
            HandleFeedbackControls(mSimTimeLine->Current()/40);
    }

    virtual void
    ButtonSelectionEvent(Button *src, void* userData)
    {
        if (src == mCheckAllBtn || src == mClearAllBtn)
        {
            bool mode = (src == mCheckAllBtn);
            for (int i=0; i<mChBoxValBars->NrOfItems(); i++)
                mChBoxValBars->GetItem(i)->ChBox()->DoSelect(mode);
        }
    }

    virtual void OnValueChanged(ValueScrollBar *src, int value,void* userData)
    {
        if (src == mPercMaximVSB)
            mSimTimeLine->PercMaxVal(value/100.f);
        if (src == mPercMeanVSB)
            mSimTimeLine->PercMaxMeanVal(value/100.f);
        if (src == mAvgFramesVSB)
        {
            SetSimilarityTableSet(mSimSet);
            SyncCheckBoxSimColors();
        }
    }


    void BuildConceptControl(Window* parent, int x, int y, int w, int h,
                             SimilarityTableSet* simSet, int options)
    {
        mTitledControl = new TitledWindow(parent,x,y,w,h,"Concept Control");
        Window* pane = mTitledControl->ContentPane();
        int paneW = pane->W();
        int paneH = pane->H();
        ScrollWnd* sWnd = new ScrollWnd(pane,0,96,paneW,paneH-96,true,0,1);
        sWnd->ConnectTo(pane);

        mChBoxValBars = new CheckBoxValueBars(sWnd->ContentHolder(),0,0,
                                              sWnd->ContentHolder()->W(),20,3);
        sWnd->ReplaceContentPane(mChBoxValBars);
        mChBoxValBars->ConnectTo(sWnd->ContentHolder(),OglGui::TOLEFTRIGHT);
        mChBoxValBars->CheckBoxWidth(160);

        mOptions = options;
        mChBoxValBars->AddChoice("");
        std::vector<std::string> names;
        if (simSet)
            names = simSet->GetNames();
        else
            names.push_back("<empty>");
        for (int i=0; i<names.size(); i++)
        {
            CheckBoxValueBar* chBoxValB =
                mChBoxValBars->AddItem(names[i],mSimTimeLine->GetSimColor(i));
            chBoxValB->ChBox()->SetCheckBoxListener(this,i);
            if (i==0)
                chBoxValB->Selected(true);
            mChBoxValBars->AddChoice(names[i]);
            StaticText* stat = new StaticText(chBoxValB,paneW-100,0,60,20,"");
            mStatistics.push_back(stat);
        }
        
        mCheckAllBtn =
            new Button(pane,0,72,68,22,"All",BEV_ETCHED,true);
        mClearAllBtn =
            new Button(pane,72,72,68,22,"None",BEV_ETCHED,true);

        mCheckAllBtn->SetButtonListener(this);
        mClearAllBtn->SetButtonListener(this);

        mShowClassifyCB = new CheckBox(pane,170,72,160,22,"Show Classification",
                                       true,BEV_ETCHED);
        mShowClassifyCB->SetRoundness(0,0,0,0);
        mShowClassifyCB->SetCheckBoxListener(this);

        (new StaticText(pane,0,48,100,22,"Avg Window"))
            ->SetAlign(oglLeftAlign);
        mAvgFramesVSB =
            new ValueScrollBar(pane,100,48,pane->W()-104,22,2,126,12);
        mAvgFramesVSB->SetValueScrollBarListener(this);
        (new StaticText(pane,0,24,100,22,"Perc Max"))
            ->SetAlign(oglLeftAlign);
        mPercMaximVSB =
            new ValueScrollBar(pane,100,24,pane->W()-104,22,20,98,66);
        mPercMaximVSB->SetValueScrollBarListener(this);
        (new StaticText(pane,0,0,100,22,"Perc Max-Avg"))
            ->SetAlign(oglLeftAlign);
        mPercMeanVSB =
            new ValueScrollBar(pane,100,0,pane->W()-104,22,4,98,25);
        mPercMeanVSB->SetValueScrollBarListener(this);
    }

private:
    void Init(int w, int h, int options, SimilarityTableSet* simSet)
    {
        int vpH   = 288 + 32 + 8; // videoH + Buttons + margin

        mChBoxValBars = 0;
        mAvgFramesVSB = 0;
        mPercMaximVSB = 0;
        mPercMeanVSB  = 0;

        mTitledVideoPlayer = new TitledWindow(this,4,4,352+8,vpH+32,"");
        Window* pane  = mTitledVideoPlayer->ContentPane();
        int     paneW = pane->W();
        int     paneH = pane->H();

        mVideoPlayerWithButtons =
            new VideoPlayerWithButtons(pane,0, 0, paneW, vpH);
        mVideoPlayerWithButtons->ConnectTo(pane);
        mVideoPlayer = mVideoPlayerWithButtons->Player();
        mVideoPlayer->NormalSpeed(true);

        Window* videoTitle = mTitledVideoPlayer->TitleText();
        mFrameNrTxt = new StaticText(videoTitle,paneW-90,2,60,20, "");
        mFrameNrTxt->SetAlign(oglLeftAlign,oglCenterAlign);
        mFrameNrTxt->ConnectTo(videoTitle,OglGui::TORIGHT);

        mTitledTimeLine = new TitledWindow(this,368,4,w-372,vpH+32,"TimeLine");
        pane = mTitledTimeLine->ContentPane();
        paneW = pane->W();
        paneH = pane->H();

        mTimeLineRuler =
            new SimilarityTimeLine(pane,0,paneH-32,paneW, 30, 0);
        mTimeLineRuler->ConnectTo(pane,OglGui::TOLEFTRIGHT | OglGui::TOTOP);
        mTimeLineRuler->SetListener(this, (void*) mVideoPlayer);
        mTimeLineRuler->SetBorderType(BEV_ETCHED);
        mTimeLineRuler->SetBorderFillShaded(2);
        mTimeLineRuler->ShowNeedle(true);
        mTimeLineRuler->SetNeedleUpDownHeight(100,100);
        mTimeLineRuler->SetNeedleColor(oglRED);
        mTimeLineRuler->ViewStripShow(false);

        int nViews = (options & 4) ? 600 : 0;
        mDocScroller = new WindowDocScroller(pane,0,0,paneW,paneH-34,1);
        mDocScroller->ConnectTo(pane);
        mSimTimeLine =
            new SimilarityTimeLine(mDocScroller,0,16,paneW,paneH-50,nViews);
        mDocScroller->SetDocWindow(mSimTimeLine,mSimTimeLine,true);

        mSimTimeLine->SetBorderType(-1);
        mSimTimeLine->SetBorderBackground(0xe0303030);
        //mSimTimeLine->SetBorderFillShaded(2);

        mSimTimeLine->SetListener(this, (void *) mVideoPlayer);

        mAxisThumb = new SizableWindow(mSimTimeLine,paneW-12,10,8,20);
        mAxisThumb->SetBorderType(BEV_ETCHED);
        mAxisThumb->SetBorderBackground(oglGREEN);
        mAxisThumb->SetBorderFillShaded(2);
        mAxisThumb->SetAllowHighlight(false);
        mAxisThumb->SetHighLightBorderType(BEV_RIDGE);
        mAxisThumb->SetMoveFeedback(true);
        mAxisThumb->SetMoveCursor(oglCursorN);

        mAxisThumb->ConnectTo(mSimTimeLine,OglGui::TORIGHT);
        mAxisThumb->SetAllowSizeDirections(15,false);
        mAxisThumb->SetAllowMoveDirections(10,false);

        mVideoPlayer->SetVideoPlayerListener(this,0);

        mOptions = options;
        mCenterNeedle = true;
        mCenterNeedleOnPlay = true;

        //ExtraTimeLine(this,368,408,w-372,182,"Extra TimeLine");

        if (!(options & 8)) // NO_CONCEPT_CONTROL
            BuildConceptControl(this,4,vpH+38,360,450,simSet,options);

        if (options & 16)
        {
            OGLVIEW* oglView = mVideoPlayer->OglView();
            int y = vpH+430;
            int h = H()-y;
            mViewAnimator =
                new OglGui::TexturedViewAnimator(this,4,vpH+430,h,h,oglView);
            view3DSys.SetZoom(mViewAnimator->OglView3D(), 1.6f, 1.6f);
            oglSys.OGLStart(mViewAnimator->GetOGLWND());
        }


        SetSimilarityTableSet(simSet);
    }

    SimilarityTableSet*                 mSimSet;

    TitledWindow*                       mTitledTimeLine;
    TitledWindow*                       mTitledVideoPlayer;
    TitledWindow*                       mTitledControl;
    SizableWindow*                      mAxisThumb;
    VideoPlayer*                        mVideoPlayer;
    VideoPlayerWithButtons*             mVideoPlayerWithButtons;

    Window*                             mFun3DWnd;
    Button*                             mCheckAllBtn;
    Button*                             mClearAllBtn;
    StaticText*                         mFrameNrTxt;
    WindowDocScroller*                  mDocScroller;
    CheckBoxValueBars*                  mChBoxValBars;
    SimilarityTimeLine*                 mSimTimeLine;
    SimilarityTimeLine*                 mTimeLineRuler;
    std::vector<SimilarityTimeLine*>    mExtraTimeLines;

    bool                                mCenterNeedleOnPlay;
    bool                                mCenterNeedle;
    int                                 mOptions;


FloatVector mMaxima;
FloatVector mMeans;
Averages mAverages;
std::vector<StaticText*> mStatistics;
ValueScrollBar*          mAvgFramesVSB;
ValueScrollBar*          mPercMaximVSB;
ValueScrollBar*          mPercMeanVSB;
CheckBox*                mShowClassifyCB;

    OglGui::TexturedViewAnimator*       mViewAnimator;
    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(SimilarityTimeLineVideo, Visualization);

} // namespace Visualization
} // namespace Impala

#endif

---