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

---

AllFramesTLineVideo.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Author: Richard van Balen
#ifndef Impala_Visualization_AllFramesTLineVideo_h
#define Impala_Visualization_AllFramesTLineVideo_h

#include "Persistency/SimilarityTableSetRepository.h"
#include "Persistency/AnnotationTableRepository.h"
#include "OglGui/CheckBox.h"
#include "OglGui/UpDownButton.h"
#include "OglGui/FramesPerSecond.h"
#include "Visualization/SimilarityTimeLineVideo.h"
#include "Core/VideoSet/SegmentationDocument.h"
#include "Core/Database/RawDataSet.h"
#include "Core/Stream/RgbDataSrcRaw.h"
#include "Visualization/AppControlDoc.h"


namespace Impala {
namespace Visualization {

class AllFramesTLineVideo : public OglGui::Window,
                            public AppControlDoc,
                            public OglGui::WindowListener,
                            public OglGui::CheckBoxListener,
                            public OglGui::ButtonListener,
                            public OglGui::UpDownButtonListener,
                            public Core::Database::DataDocumentListener
{
public:
    static const int SHOW_SHOT_BOUNDARIES   = 1;
    static const int SHOW_VIEWSTRIP         = 2;
    static const int NEXT_PREV_SHOT         = 3;
    static const int NEXT_PREV_KEYFRAME     = 4;
    static const int VIEWSTRIP_PRE          = 5;
    static const int VIEWSTRIP_MIN          = 6;
    static const int VIEWSTRIP_MAX          = 7;
    static const int CENTER_NEEDLE          = 8;
    static const int CENTER_NEEDLE_ONPLAY   = 9;
    static const int EXTRA_TIMELINE         = 10;
    static const int NEXT_PREV_POSITIVE     = 11;
    // Leave 20 for NEX_PREV_POSITIVE
    static const int VALIDATE               = 31;

    typedef OglGui::CheckBox                        CheckBox;
    typedef OglGui::StaticText                              StaticText;
    typedef OglGui::Button                                      Button;
    typedef OglGui::UpDownButton                        UpDownButton;

    typedef Core::VideoSet::SegmentationDocument    SegmentationDocument;
    typedef Core::VideoSet::Segmentation            Segmentation;
    typedef Core::VideoSet::Keyframes               Keyframes;
    typedef Core::Table::SimilarityTableSet         SimilarityTableSet;
    typedef SimilarityTableSet::SimTableType        SimTableType;

    typedef std::vector<int>                        IntVector;
    typedef std::vector<IntVector*>                 AnnoPositives;
    typedef std::vector<float>                      FloatVector;
    typedef std::vector<FloatVector*>               Averages;

    typedef Core::Table::AnnotationTable            AnnotationTable;

    typedef Core::Stream::RgbDataSrcRaw             RgbDataSrcRaw;
    typedef Core::Stream::RgbDataSrcFactory         RgbDataSrcFactory;
    typedef Core::Stream::RgbDataSrc                RgbDataSrc;
    typedef Core::Database::RawDataSet              RawDataSet;

    typedef Core::VideoSet::VideoSet                VideoSet;

    AllFramesTLineVideo(OglGui::Window* parent,int wndW, int wndH,
                        SegmentationDocument* segDoc, int controlId) :
        Window(parent,0,0,wndW, wndH, true),
        AppControlDoc(controlId, segDoc)
    {
        Init(wndW, wndH, segDoc);
    }

    void HandleNewVideo()
    {
        VideoSet*   videoSet    = mSegDoc->GetVideoSet();
        String      videoName   = videoSet->GetFile(mCurFile);
        bool        vidIsMpg    = !mTimeLineVideoRaw;
        bool        stripIsMpg  = !mViewStripVideoRaw;

        RgbDataSrc* rgbDataSrc;
        if (mTimeLineVideoRaw)
            rgbDataSrc = videoSet->GetVideoInLowResolution(mCurFile, true);
        if (!mTimeLineVideoRaw || (mTimeLineVideoRaw && !rgbDataSrc))
        {
            rgbDataSrc = videoSet->GetVideo(mCurFile);
            vidIsMpg = true;
        }
        mSimTLV->OpenVideo(rgbDataSrc,videoName);

        SimilarityTimeLine* timeLine = mSimTLV->TimeLine();
        if (mShowViewStrip)
        {
            timeLine->ViewStripRgbDataSrc((RgbDataSrc*)0);
            timeLine->SetAxisY(mTLVAxisY);
            timeLine->ViewStripY(mViewStripY);
            timeLine->ViewStripFrameStep(mViewStripStep);
            timeLine->ViewStripMinViewWidth(mViewStripMinW);
            timeLine->SetNeedleColor(mNeedleColor);
        }
        if (mShowViewStrip)
        {
            if (mViewStripVideoRaw)
                rgbDataSrc = videoSet->GetVideoInLowResolution(mCurFile, true);
            if (!mViewStripVideoRaw || (mViewStripVideoRaw && !rgbDataSrc))
            {
                rgbDataSrc = videoSet->GetVideo(mCurFile);
                stripIsMpg = true;
            }
            timeLine->ViewStripRgbDataSrc(rgbDataSrc);
        }
        timeLine->mBothMpg = (stripIsMpg && vidIsMpg);

        mSimTLV->Player()->GotoFrame(mSegDoc->CurFrame());
        ConstructPositives();
    }
#if 0
    void HandleNewVideo()
    {
        VideoSet    videoSet    = mSegDoc->GetVideoSet();
        RawDataSet* dataSet     = mSegDoc->GetDataSet();
        String      videoName   = dataSet->GetFile(mCurFile);
        bool        vidIsMpg    = !mTimeLineVideoRaw;
        bool        stripIsMpg  = !mViewStripVideoRaw;

        RgbDataSrc* rgbDataSrc = videoSet->GetVideo(mCurFile, mTimeLineVideoRaw);
        if (mTimeLineVideoRaw && !rgbDataSrc)
        {
            rgbDataSrc = videoSet->GetVideo(mCurFile);
            vidIsMpg = true;
        }
        mSimTLV->OpenVideo(rgbDataSrc,videoName);

        SimilarityTimeLine* timeLine = mSimTLV->TimeLine();
        if (mShowViewStrip)
        {
            timeLine->ViewStripRgbDataSrc((RgbDataSrc*)0);
            timeLine->SetAxisY(mTLVAxisY);
            timeLine->ViewStripY(mViewStripY);
            timeLine->ViewStripFrameStep(mViewStripStep);
            timeLine->ViewStripMinViewWidth(mViewStripMinW);
            timeLine->SetNeedleColor(mNeedleColor);
        }
        if (mShowViewStrip)
        {
            RgbDataSrc* dataSrc = videoSet->GetVideo(mCurFile, mViewStripVideoRaw);
            if (mViewStripVideoRaw && !dataSrc)
            {
                dataSrc = videoSet->GetVideo(mCurFile);
                stripIsMpg = true;
            }
            timeLine->ViewStripRgbDataSrc(dataSrc);
        }
        timeLine->mBothMpg = (stripIsMpg && vidIsMpg);

        mSimTLV->Player()->GotoFrame(mSegDoc->CurFrame());
        ConstructPositives();
    }
#endif 0

    void HandleNewSimSet()
    {
        bool        doExtra   = false;
        RawDataSet* dataSet   = mSegDoc->GetDataSet();
        //std::string dir       = dataSet->GetFile(mCurFile);
        //std::string simNames  = mTimeLineVideoSimDir+"/"+dir+"/names.txt";
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        std::string simNames =
            dataSet->GetFilePathSimilarityData("Frames", mConceptSet, mConceptModel,
                                               mConceptFeature, mCurFile,
                                               "names.txt", false, false);

        if (mSimSet)
            delete mSimSet;
        mSimSet = 0;
        if (!simNames.empty())
            mSimSet = SimilarityTableSet::MakeFromFile(simNames,
                                                       dataSet->GetDatabase());
#else // REPOSITORY_USED
        typedef Persistency::SimilarityTableSetLocator SimLoc;
        SimLoc loc(dataSet->GetLocator(), false, "Frames", mConceptSet,
                   mConceptModel, mConceptFeature,
                   dataSet->GetContainerFile(mCurFile));
        if (mSimSet)
            delete mSimSet;
        mSimSet = Persistency::SimilarityTableSetRepository().Get(loc);
#endif // REPOSITORY_USED

        if (!mSimTLV)
        {
            int m = 0; //  = (mNoValues ? 0 : 1) | (mNoBars ? 0 : 2);
            m |= mShowViewStrip ? 4 : 0;
            m |= mTimeLineVideo3D ? 16 : 0;
            mSimTLV = new SimilarityTimeLineVideo(this,0,30,W(),H()-30,
                                                  mSimSet,m);
            SimilarityTimeLine* simTL = mSimTLV->TimeLine();
            simTL->SetWindowListener(this);
            simTL->FrameError(mFrameError);
            mSimTLV->ConnectTo(this);
            mSimTLV->ScaleChildren(0,0);
            doExtra = true;
        }
        else
            mSimTLV->SetSimilarityTableSet(mSimSet);
        HandleNewVideo();
        if (doExtra)
            HandleExtraTimeLines();
    }

    virtual void
    HandleNewFile()
    {
        if (!mSegDoc->HasCursor())
        {
            mCurFile = -1;
            return;
        }
        int fileId  = mSegDoc->CurFileId();
        if (fileId == mCurFile && mSimTLV)
        {
            mSimTLV->Player()->GotoFrame(mSegDoc->CurFrame()-mFrameError/*+15*/);
            return;
        }
        mCurFile = fileId;
        HandleNewSimSet();
    }

    virtual void CheckBoxEvent(CheckBox *src, bool checked, void* vData)
    {
        int userData = (long long) vData;
        if (userData == SHOW_SHOT_BOUNDARIES)
            mShowBoundaries = checked;
        if (userData == SHOW_VIEWSTRIP)
            mSimTLV->TimeLine()->ViewStripShow(checked);
        if (userData == CENTER_NEEDLE_ONPLAY)
            mSimTLV->CenterNeedleOnPlay(checked);
        if (userData == CENTER_NEEDLE)
            mSimTLV->CenterNeedle(checked);
    }

    int FindFrameShot(int frame)
    {
        Segmentation* seg       = mSegDoc->GetSegmentation();
        int           firstShot = seg->GetFirstShotVideo(mCurFile);
        int           lastShot  = firstShot+seg->GetNrShotsVideo(mCurFile);
        int               i;

        for (i=firstShot; i<lastShot; i++)
            if (seg->GetStart(i) > frame)
                break;
        return i-1;
    }

    void GoToAdjacentShot(bool next)
    {
        Segmentation*   seg              = mSegDoc->GetSegmentation();
        int                             curFrame = mSimTLV->Player()->FrameNr();
        int                             nextShot = FindFrameShot(curFrame) + (next?1:-1);
        mSimTLV->TimeLine()->Current(seg->GetStart(nextShot)*40);
    }

    int FindAdjacentKeyFrame(int frame, bool next)
    {
        Keyframes* keys        = mSegDoc->GetKeyframes();
        int        firstKeyFr  = keys->GetFirstKeyframeVideo(mCurFile);
        int        lastKeyFr   = firstKeyFr+keys->GetNrKeyframesVideo(mCurFile);
        int        i, k, prevK;

        //frame -= 15; // Compensate 15 for keyFrameError
        frame += next ? 1 : 0;
        for (i=firstKeyFr; i<lastKeyFr; i++)
        {
            if ((k=keys->GetFrameNr(i))<frame)
                prevK = k;
            else
                break;
        }
        return /* 15 + */ (next ? k : prevK); // Compensate 15 for keyFrameError 
    }

    void GoToAdjacentKeyFrame(bool next)
    {
        int      curFrame  = mSimTLV->Player()->FrameNr();
        int  nFrame    = FindAdjacentKeyFrame(curFrame,next);
        mSimTLV->TimeLine()->Current(nFrame*40);
    }

    int FindAdjacentPositive(int id, int frame, bool next)
    {
        int        i, k, prevK;

        frame += next ? 1 : 0;
        IntVector* positiveVector = mAnnoPositives[id];

        for (i=0; i<positiveVector->size(); i++)
        {
            if ((k=(*positiveVector)[i])<frame)
                prevK = k;
            else
                break;
        }
        return /* 15 + */ (next ? k : prevK); // Compensate 15 for keyFrameError 
    }

    void GoToAdjacentPositive(int id, bool next)
    {
        int      curFrame  = mSimTLV->Player()->FrameNr();
        int  nFrame    = FindAdjacentPositive(id,curFrame,next);
        mSimTLV->TimeLine()->Current(nFrame*40);
    }

    virtual void
    UpDownButtonSelectionEvent(UpDownButton *src, bool isUpBtn, void* vData)
    {
        int userData = (long long) vData;
        if (userData == NEXT_PREV_SHOT) // Shot boundaries
            GoToAdjacentShot(isUpBtn);
        if (userData==NEXT_PREV_KEYFRAME)
            GoToAdjacentKeyFrame(isUpBtn);
        if (userData>=NEXT_PREV_POSITIVE && userData<NEXT_PREV_POSITIVE+20)
            GoToAdjacentPositive(userData-NEXT_PREV_POSITIVE,isUpBtn);
        mSimTLV->TimeLine()->MakeCurrentVisible();
    }

    virtual void ButtonSelectionEvent(Button *src, void* vData)
    {
        int userData = (long long) vData;
        if (userData==VIEWSTRIP_PRE)
            mSimTLV->TimeLine()->ViewStripZoomToShowViews(0);
        if (userData==VIEWSTRIP_MIN)
            mSimTLV->TimeLine()->ViewStripZoomToShowViews(1);
        if (userData==VIEWSTRIP_MAX)
            mSimTLV->TimeLine()->ViewStripZoomToShowViews(2);
        if (userData==EXTRA_TIMELINE)
            mSimTLV->ExtraTimeLine(mSimTLV, mSimTLV->TitledTimeLine()->X(),
                                   mSimTLV->H()-200,
                                   mSimTLV->TitledTimeLine()->W(),182,
                                   "Extra TimeLine");
        if (userData==VALIDATE)
            AnnoValidate();
    }

    void AnnoValidate()
    {
        RawDataSet* dataSet      = mSegDoc->GetDataSet();
        std::string dir          = dataSet->GetFile(mCurFile);

        printf("\n\nValidation %s\n--------------------------------------\n",
               dir.c_str());
        SimilarityTimeLine* timeLine = mSimTLV->TimeLine();
        for (int a=0; a<mAnnoTables.size(); a++)
        {
            AnnotationTable* anno   = mAnnoTables[a];
            FloatVector*     avgVector = (*mSimTLV->GetAverages())[a];

            int nPosCorrect=0, nPosInCorrect = 0;
            int nFalseCorrect=0, nFalseInCorrect= 0;
            int n = 0;
            float maxim  = (*mSimTLV->Maxima())[a];
            float mean   = (*mSimTLV->Means())[a];

            int sz = anno->Size();
            for (int i=0; i<sz; i++)
            {
                Quid    quid    = anno->Get1(i);
                float   qual    = anno->Get2(i);
                int     vidId   = QuidObject(quid);
                int     frameId = QuidId(quid);
                if (vidId==mCurFile)
                {
                    float sim = (*avgVector)[frameId];
                    bool isConcept = timeLine->PassTest(sim,maxim,mean);
                    if (qual > 0)
                    {
                        if (isConcept)
                            nPosCorrect++;
                        else
                            nPosInCorrect++;
                    }
                    if (qual < 0)
                    {
                        if (isConcept)
                            nFalseInCorrect++;
                        else
                            nFalseCorrect++;
                    }
                    n++;
                }
            }
            printf("%18s: %3d TruePos, %3d FalseNeg, TrueNeg %3d FalsePos %3d\n",
                mSimSet->GetNames()[a].c_str(), nPosCorrect, nPosInCorrect, nFalseCorrect, nFalseInCorrect);
        }
    }

    void ReadAnnotations()
    {
        AnnotationTable *anno;

        for (int i=0; i<mSegDoc->NrConcepts(); i++)
        {
            anno = 0;
            Core::VideoSet::VideoSet* vidSet = mSegDoc->GetVideoSet();
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            std::string fName = vidSet->GetFilePathAnnotation
                (QUID_CLASS_FRAME, mConceptAnnotations,
                 mSegDoc->GetConcept(i)+".tab", false, true);
            if (fName.empty())
                printf("No annotions for %s\n", mSegDoc->GetConcept(i).c_str());
            else
                anno = Core::Table::AnnotationTable::MakeFromFile
                    (mSegDoc->GetConcept(i), fName, vidSet->GetDatabase());
#else // REPOSITORY_USED
            typedef Persistency::AnnotationTableLocator AnnoLoc;
            AnnoLoc loc(vidSet->GetLocator(), QUID_CLASS_FRAME,
                        mConceptAnnotations, mSegDoc->GetConcept(i));
            if (Persistency::AnnotationTableRepository().Exists(loc))
                anno = Persistency::AnnotationTableRepository().Get(loc);
#endif // REPOSITORY_USED
            if (anno)
                mAnnoTables.push_back(anno);
        }
    }

    void ClearPositives()
    {
        for (int i=0; i<mAnnoPositives.size(); i++)
            delete mAnnoPositives[i];
        mAnnoPositives.clear();
    }
        
    void ConstructPositives()
    {
        ClearPositives();

        int sz = mAnnoTables.size();
        for (int a=0; a<sz; a++)
        {
            AnnotationTable* anno           = mAnnoTables[a];
            IntVector*       positiveVector = new IntVector;

            for (int i=0; i<anno->Size(); i++)
            {
                Quid    quid    = anno->Get1(i);
                float   qual    = anno->Get2(i);
                int     vidId   = QuidObject(quid);
                int     frameId = QuidId(quid);

                if (vidId == mCurFile && qual > 0)
                    positiveVector->push_back(frameId);
            }
            mAnnoPositives.push_back(positiveVector);
        }
    }

    virtual void WindowDisplayEvent(OglGui::Window *src, void* userData)
    {
        ShowBoundaries((SimilarityTimeLine*) src);
        ShowPositives((SimilarityTimeLine*) src);

        if (!mChBoxValueBars)
        {
            mChBoxValueBars = mSimTLV->ChBoxValueBars();
            OglGui::CheckBoxValueBar*  chBoxVB;
            int item = 0;
            while( chBoxVB = mChBoxValueBars->GetItem(item) )
            {
                UpDownButton* upDownBtn
                    = RightUpDownButton(chBoxVB,20,12,NEXT_PREV_POSITIVE+item);
                item++;
            }
        }
    }

    void ShowBoundaries(SimilarityTimeLine* simTL)
    {
        if (!mShowBoundaries)
            return;

        Segmentation* seg   = mSegDoc->GetSegmentation();
        int firstShot       = seg->GetFirstShotVideo(mCurFile);
        int nrShots         = seg->GetNrShotsVideo(mCurFile);
        int frameErr        = simTL->FrameError();

        int y = simTL->GetAxisY();

        int i, x, frame;

        SetSolidLineColor(0xffff8050);
        for (i=firstShot; i<firstShot+nrShots; i++)
        {
            frame = seg->GetStart(i);
            x = simTL->Unit2Pixel((frame-frameErr)*40);
            DrawLine(x,y-16,x,y+200);
        }

        Keyframes* keys = mSegDoc->GetKeyframes();
        int firstKeyfr = keys->GetFirstKeyframeVideo(mCurFile);
        int nrKeys = keys->GetNrKeyframesVideo(mCurFile);

        int curFr = mSegDoc->CurFrame();
        for (i=firstKeyfr; i<firstKeyfr+nrKeys; i++)
        {
            frame = keys->GetFrameNr(i);
            ULONG col = keys->IsRKF(i) ? oglRED : oglBLUE;
            if (curFr == frame)
                col = oglGREEN;
            SetSolidLineColor(col);
            x = simTL->Unit2Pixel((frame-frameErr/*+15*/)*40);
            //x = simTL->Unit2Pixel((frame-frameErr)*40);
            DrawLine(x,y-16,x,y+100);
        }
    }

    void ShowPositives(SimilarityTimeLine* simTL)
    {
        if (!mShowPositives)
            return;

//Segmentation* seg = mSegDoc->GetSegmentation();

        int y = simTL->GetAxisY();

        SetLineWidth(3);
        int nConcepts = mAnnoPositives.size();
        for (int i=0; i<nConcepts; i++)
        {
            if (!simTL->GetShowSim(i))
                continue;

            ULONG col = simTL->GetSimColor(i);
            SetSolidLineColor(col);
            IntVector* positiveVector = mAnnoPositives[i];
            int sz = positiveVector->size();
            for (int p=0; p<sz; p++)
            {
                int posFrame = (*positiveVector)[p];
                int x = simTL->Unit2Pixel(posFrame*40);
                DrawLine(x,y-(i*2)-2,x,y-20);
/*
SetLineWidth(1);
int shot = FindFrameShot(posFrame);
int prevShot = seg->GetStart(shot);
int     nextShot = seg->GetStart(shot+1);
                int yShot = y-(i*2)-2;
                int x1 = simTL->Unit2Pixel(prevShot*40);
                int x2 = simTL->Unit2Pixel(nextShot*40);
                DrawLine(x1,yShot,x2,yShot);
SetLineWidth(3);
*/
            }
        }
        SetLineWidth(1);
    }

private:
    void HandleExtraTimeLines()
    {
        for (int i=0; i<mNrExtraTimeLines; i++)
        {
            int x,y,w,h,tlvH=mSimTLV->H();
            mSimTLV->TitledTimeLine()->GetDimensions(x,y,w,h);
            int nH = (tlvH - (y+h))/mNrExtraTimeLines;
            OglGui::TitledWindow* titledWnd =
                mSimTLV->ExtraTimeLine(mSimTLV,x,tlvH-(mNrExtraTimeLines-i)*nH,
                                       w,nH-2,"Extra TimeLine");
            titledWnd->ScaleTo(this);
            mSimTLV->TimeLineExtra(i)->DocX(30);
            int oldW = mSimTLV->TimeLineExtra(i)->DocW();
            int n = (mNrExtraTimeLines-i);
            mSimTLV->TimeLineExtra(i)->DocW((n*n*15)*oldW);
        }
        if (mNrExtraTimeLines>0)
        {
            int oldW = mSimTLV->TimeLine()->DocW();
            mSimTLV->TimeLine()->DocX(30);
            int n = (mNrExtraTimeLines+2);
            mSimTLV->TimeLine()->DocW(n*n*15*oldW);
        }
    }

    void HandleOptions()
    {
        CmdOptions& options = CmdOptions::GetInstance();

        mFrameError             = options.GetInt("timeLineVideoFrameError");
        mTimeLineVideoRaw       = options.GetBool("timeLineVideoRaw");
        mViewStripVideoRaw      = options.GetBool("viewStripVideoRaw");
        //mTimeLineVideoDir       = options.GetString("timeLineVideoDir");
        //mTimeLineVideoSimDir    = options.GetString("timeLineVideoSimDataDir");
        //mTimeLineVideoSimSubDir = options.GetString("timeLineVideoSimDataSubDir");
        mConceptSet             = options.GetString("conceptSet");
        mConceptModel           = options.GetString("conceptModel");
        mConceptFeature         = options.GetString("conceptFeature");
        mConceptAnnotations     = options.GetString("conceptAnnotations");
        mTimeLineVideo3D        = options.GetBool("timeLineVideo3D");
        mTLVAxisY               = options.GetInt("timeLineVideoAxisY");
        //mNoValues               = options.GetBool("timeLineVideoNoValues");
        //mNoBars                 = options.GetBool("timeLineVideoNoBars");
        mShowViewStrip          = options.GetBool("viewStrip");
        mViewStripUseMem        = options.GetBool("viewStripUseMemory");
        mViewStripY             = options.GetInt("viewStripY");
        mViewStripStep          = options.GetInt("viewStripStep");
        mViewStripMinW          = options.GetInt("viewStripMinWidth");
        //mViewStripDir           = options.GetString("viewStripRawDir");
        std::string needleColS  = options.GetString("timeLineNeedleColor");
        mNrExtraTimeLines       = options.GetInt("timeLineExtra");

        if (mFrameError == -1)
            mFrameError = 0;
        //if (mViewStripDir.empty())
        //    mViewStripDir = mTimeLineVideoDir;
        //if (!mTimeLineVideoSimSubDir.empty())
        //    mTimeLineVideoSimDir += "/" + mTimeLineVideoSimSubDir;
        if (mConceptFeature.empty())
            mConceptFeature = "combined";
        if (mTLVAxisY == -1)
            mTLVAxisY = 20;
        if (mViewStripY == -1)
            mViewStripY = 24;
        if (mViewStripStep == -1)
            mViewStripStep = 1;
        if (mViewStripMinW < 4)
            mViewStripMinW = 4;
        if (!needleColS.empty())
            mNeedleColor = OglColorStr(needleColS.c_str());
    }

    CheckBox*
    ScaledCheckBox(Window* parent, int x, int y, int w, int h,
                   strconst str, bool checked, int userData)
    {
        CheckBox* cb =
            new CheckBox(parent,x,y,w,h,str,checked,BEV_ETCHED);
        //cb->ConnectTo(parent, OglGui::TOBOTTOMLEFT);
        cb->ScaleTo(parent);
        cb->SetCheckBoxListener(this,(void*)userData);
        cb->SetBorderFillShaded(0);
        cb->SetAllowScaling(false);
        return cb;
    }

    UpDownButton*
    RightUpDownButton(Window* parent, int w, int h, int userData)
    {
        int y = (parent->H()-h)/2;
        int x = parent->W()-w-2;
        UpDownButton* upDownBtn = new UpDownButton(parent,x,y,w,h,true);
        //upDownBtn->ConnectTo(parent, OglGui::TORIGHT | OglGui::TOTOPBOTTOM);
        upDownBtn->ScaleTo(parent);
        upDownBtn->SetUpDownButtonListener(this,(void*)userData);
        upDownBtn->SetRepeatMode(true);
        upDownBtn->SetAllowScaling(false);
        return upDownBtn;
    }

    Button*
    ViewStripButton(Window* parent, int x, int w, strconst str, int lData)
    {
        Button *btn = new Button(parent,x,2,w,parent->H()-4,str,BEV_ETCHED,true);
        //btn->ConnectTo(parent,OglGui::TORIGHT | OglGui::TOTOPBOTTOM);
        btn->ScaleTo(parent);
        btn->SetButtonListener(this, (void*)lData);
        btn->SetAllowScaling(false);
        return btn;
    }

    void Init(int w, int h, SegmentationDocument* segDoc)
    {
        mSegDoc = segDoc;
        mCurFile = 0;
        mSimTLV = 0;
        mSimSet = 0;
        mNeedleColor = 0xffC0C0C0;
        mShowBoundaries = false;
        mShowPositives = true;
        AddDocListener(this);

        HandleOptions();
        ReadAnnotations();
        SetBorderType(-1);
        SetBorderBackground(0x80808080);
        //SetBorderFillShaded(2);

        new OglGui::FramesPerSecond(this,W()-76,4,70,28);

        CheckBox* cb = ScaledCheckBox(this,4,4,130,24,"Boundaries",false,
                                      SHOW_SHOT_BOUNDARIES);
        UpDownButton* upDownBtn = RightUpDownButton(cb,30,20,NEXT_PREV_SHOT);

        StaticText* txt = new StaticText(this,140,4,96,24,"keyframe");
        txt->SetAlign(oglLeftAlign,oglCenterAlign);
        txt->SetBorderType(BEV_ETCHED);
        upDownBtn = RightUpDownButton(txt,30,20,NEXT_PREV_KEYFRAME);

        if (!mShowViewStrip)
            return;
        cb = ScaledCheckBox(this,250,4,184,24,"ViewStrip",true,SHOW_VIEWSTRIP);

        Button* btn;
        btn = ViewStripButton(cb, 84,32,"Pre",VIEWSTRIP_PRE);
        btn = ViewStripButton(cb,116,32,"Min",VIEWSTRIP_MIN);
        btn = ViewStripButton(cb,148,32,"Max",VIEWSTRIP_MAX);

        cb = ScaledCheckBox(this,438,4,200,24,"Center Needle",true,
                            CENTER_NEEDLE);

        ScaledCheckBox(cb,116,0,84,24,"On Play",
                            true, CENTER_NEEDLE_ONPLAY);

        btn = new Button(this,cb->X()+cb->W()+4,4,140,24,"Extra TimeLine",
                         BEV_ETCHED,true);
        btn->SetButtonListener(this, EXTRA_TIMELINE);

        btn = new Button(this,btn->X()+btn->W()+6,4,80,24,"Validate",
                         BEV_ETCHED,true);
        btn->SetButtonListener(this, VALIDATE);
        mChBoxValueBars = 0;
    }

    SegmentationDocument*         mSegDoc;
    SimilarityTableSet*           mSimSet;
    SimilarityTimeLineVideo*      mSimTLV;

    std::vector<AnnotationTable*> mAnnoTables;
    AnnoPositives                 mAnnoPositives;
    OglGui::CheckBoxValueBars*    mChBoxValueBars;

    RgbDataSrcRaw*                mRgbDataSrcRaw;

    //std::string                   mTimeLineVideoDir;
    //std::string                   mViewStripDir;
    //std::string                   mTimeLineVideoSimDir;
    //std::string                   mTimeLineVideoSimSubDir;
    std::string                   mConceptSet;
    std::string                   mConceptModel;
    std::string                   mConceptFeature;
    std::string                   mConceptAnnotations;
    bool                          mTimeLineVideo3D;
    bool                          mViewStripUseMem;

    bool                          mViewStripVideoRaw;
    bool                          mTimeLineVideoRaw;

    bool                          mShowBoundaries;
    bool                          mShowPositives;
    //bool                          mNoValues;
    //bool                          mNoBars;
    bool                          mShowViewStrip;
    int                           mViewStripY;
    int                           mViewStripStep;
    int                           mViewStripMinW;
    int                           mTLVAxisY;
    ULONG                         mNeedleColor;
    int                           mCurFile;
    int                           mFrameError;
    int                           mNrExtraTimeLines;

    bool                          mOldNoKeyListening;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(AllFramesTLineVideo, Visualization);

} // namespace Visualization
} // namespace Impala

#endif

---