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

---

SegmentationDocumentGuiAnno.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef Impala_Visualization_SegmentationDocumentGuiAnno_h
#define Impala_Visualization_SegmentationDocumentGuiAnno_h

//#include "OglGui/SplashScreenWoggel.h"

#include "Persistency/Mpeg7DocRepository.h"
#include "Persistency/SimilarityTableSetRepository.h"
#include "Core/VideoSet/SegmentationDocument.h"
#include "Core/VideoSet/Mpeg7DocWrite.h"
#include "Core/Stream/RgbDataSrcFactory.h"
#include "Core/Stream/RgbDataSrcRaw.h"
#include "Core/Table/SimilarityTableSet.h"

#include "Visualization/SimilarityTimeLineVideo.h"
#include "Visualization/ImageStrip.h"
#include "Visualization/ImageSet.h"
#include "Visualization/DataDocumentGui.h"

#include "OglGui/TextArea.h"
#include "OglGui/Strut.h"
#include "OglGui/Button.h"
#include "OglGui/ValueScrollBar.h"
#include "OglGui/UpDownNumber.h"

namespace Impala {
namespace Visualization {

class SegmentationDocumentGuiAnno :
            public DataDocumentGui<Core::VideoSet::SegmentationDocument>,
            public ImagesListener,
            public OglGui::ViewListener,
            public OglGui::WindowListener,
            public OglGui::CheckBoxListener,
            public OglGui::ValueScrollBarListener,
            public OglGui::UpDownButtonListener,
            public OglGui::UpDownNumberListener
{
    static const int BUT_POSITIVE               = 100;
    static const int BUT_SKIP                   = 101;
    static const int BUT_NEGATIVE               = 102;
    static const int BUT_SAVE                   = 103;
    static const int BUT_BACK                   = 104;
    static const int BUT_FORW                   = 105;
    static const int BUT_SHOT_POS               = 106;
    static const int BUT_SHOT_NEG               = 107;
    static const int BUT_LEFT_SHOT              = 108;
    static const int BUT_RIGHT_SHOT             = 109;
    static const int BUT_SYNC                   = 110;
    static const int VIEWSTRIP_PRE              = 111;
    static const int VIEWSTRIP_MIN              = 112;
    static const int VIEWSTRIP_MAX              = 113;
    static const int BUT_NAV_MODE               = 114;
    static const int BUT_NAV_BEGIN              = 115;
    static const int BUT_NAV_END                = 116;
    static const int BUT_RANK_ALL               = 117;
    static const int BUT_RANK_NOT_ANN           = 118;

    static const int UPDOWNBUT_POSITIVE         = 130;
    static const int UPDOWNBUT_SKIPPED          = 131;
    static const int UPDOWNBUT_NEGATIVE         = 132;
    static const int UPDOWNBUT_UNKNOWN          = 133;

    static const int CHBOX_RANK_MODE            = 203;
    static const int CHBOX_SHOW_THRESH_SHOTS    = 204;
    static const int CHBOX_SHOW_SEG_SHOTS       = 205;
    static const int CHBOX_PN_IN_VIDEO          = 206;

    static const int UNKNOWN_BIT                = 1;
    static const int POSITIVE_BIT               = 2;
    static const int SKIPPED_BIT                = 4;
    static const int NEGATIVE_BIT               = 8;

public:

    typedef std::vector<UCHAR>                      VideoAnnotation;
    typedef std::vector<VideoAnnotation*>           VideoAnnotations;

    typedef Core::VideoSet::SegmentationDocument    SegmentationDocument;
    typedef Core::VideoSet::Segmentation            Segmentation;
    typedef Core::Array::Array2dVec3UInt8           Array2dVec3UInt8;
    typedef Core::VideoSet::Mpeg7Doc                Mpeg7Doc;
    typedef Core::Stream::RgbDataSrc                RgbDataSrc;
    typedef Core::Stream::RgbDataSrcRaw             RgbDataSrcRaw;
    typedef Core::Stream::RgbDataSrcFactory         RgbDataSrcFactory;
    typedef Core::Table::SimilarityTableSet         SimilarityTableSet;

    typedef Visualization::SimilarityTimeLineVideo  SimilarityTimeLineVideo;

    typedef SimilarityTableSet::SimTableType        SimTableType;
    typedef SimilarityTableSet::RankTableType       RankTableType;

    typedef OglGui::TitledWindow                    TitledWindow;
    typedef OglGui::Button                          Button;
    typedef OglGui::StaticText                      StaticText;
    typedef OglGui::TextArea                        TextArea;
    typedef OglGui::CheckBox                        CheckBox;
    typedef OglGui::UpDownButton                    UpDownButton;
    typedef OglGui::UpDownNumber                    UpDownNumber;
    typedef OglGui::ValueScrollBar                  ValueScrollBar;
    typedef OglGui::Strut                           Strut;

    struct AnnoHistory {
        int fileIdx;
        int frameIdx;
        int rankIdx;
    };

    SegmentationDocumentGuiAnno(OglGui::Window* parent, int wndWidth,
                  int wndHeight, SegmentationDocument* segDoc,
                  String conceptSet, int maxAnnoPerVideo,
                              int controlId) :
        DataDocumentGui<SegmentationDocument>(parent, wndWidth, wndHeight,
                                              segDoc, controlId, true,
                                              false, false, 2, 4, true,
                                              false)
    {
        Init(segDoc, conceptSet, maxAnnoPerVideo);
    }

    virtual void HandleActivate()
    {
        mNoAutoNextAnno = true;
        AppControlDoc::HandleActivate();
        mNoAutoNextAnno = false;
    }
    
    virtual void
    HandleNewFile()
    {
        DataDocumentGui<SegmentationDocument>::HandleNewFile();
        int oldCurFile = mCurFile;
        CheckLoadMpeg7();

        if (mAnnoSearching)
            return;

        // RvB ShotSimilarWnd: oldCurFile because CheckLoadMpeg7 sets curFile
        CheckNewVideo(oldCurFile);
        HandleNewShot();
        if (mRankingMode)
            CheckAnnoMax();
    }

    virtual void
    HandleNewShot()
    {
        if (mAnnoSearching)
            return;
        mImWnd->RemoveImages();
        mImShotWnd->RemoveImages();
        mCurShotFrames.clear();

        mFrameText->SetText("");
        if (!(mKeyframes && mKeyframeSet))
            return;
        int shot = mSegDoc->CurShot();
        if (shot == -1)
            return;

        // Line below conflicts with annotations
        // as annotations only work based on RKF keyframes
        // if ((mCurKey = mSegDoc->CurKeyfr())==-1)
            mCurKey = mKeyframes->GetShotRKF(shot);
        mImWnd->AddImage(mCurKey, mKeyframeSet);

        int frame = mKeyframes->GetFrameNr(mCurKey);
        int firstFrame = -1, lastFrame = -1;
                int     idx = -1;
            if (mCurMpeg7)
            {
            idx = mCurMpeg7->FindShot(frame);
            if (idx != -1)
            {
                firstFrame = mCurMpeg7->StartFrame(idx);
                lastFrame  = mCurMpeg7->EndFrame(idx);
            }
            }
        if (firstFrame == lastFrame)
        {
            if ((shot = FindFrameShot(frame))==-1)
                return;
            firstFrame = mShots[shot]+1;
            lastFrame  = mShots[shot+((shot<mShots.size()-1) ? 1 : 0)];
        }
        FillShotSample(firstFrame, lastFrame, frame);
        UpdateRelevance();
        if (mSimTLV)
        {
            if (mAllowSlidingChBox)
                mFrameSliding = mAllowSlidingChBox->GetSelected();
            if (mFrameSliding)
                mSimTLV->Player()->MoveToFrame(frame);
            else
                mSimTLV->Player()->GotoFrame(frame);
        }
    }

    void FillShotSample(int firstFrame, int lastFrame, int curFrame)
    {
        if (firstFrame > curFrame)
            firstFrame = curFrame;
        if (lastFrame < curFrame)
            lastFrame = curFrame;
        if (firstFrame > lastFrame)
        {
            int tmp = lastFrame;
            lastFrame = firstFrame;
            firstFrame = tmp;
        }
        mImShotWnd->RemoveImages();
        mCurShotFrames.clear();
        if (mRgbDataSrc && firstFrame < lastFrame)
        {
            if (mShotValueSB)
            {
                mShotValueSB->SetVisible(true);
                mShotValueSB->SetMinMaxValue(firstFrame, lastFrame);
            }

            int nrShotFrames = lastFrame-firstFrame;
            if (nrShotFrames > 1)
            {
                float step = (nrShotFrames<5)? 1.f : nrShotFrames/4.f;
                for (float i=firstFrame; i<=lastFrame; i += step)
                    ToShotWindow(i,((int)i)==curFrame);
            }
        }
    }

    void ToShotWindow(int idx, bool isKeyFrame=false)
    {
        char buf[60];
        sprintf(buf,isKeyFrame?"%d (*)" : "%d", idx);
        Array2dVec3UInt8* arrIm = GetFrameArrIm(idx);
        mImShotWnd->AddImage(arrIm,"Direct",buf,true,false);
        mCurShotFrames.push_back(idx);
    }


    VideoAnnotations* GetVideoAnnotations()
    {
        return &mVideoAnnotations;
    }


    Array2dVec3UInt8* GetFrameArrIm(int frameNr)
    {
        if (!mRgbDataSrc)
            return 0;

        int imW = mRgbDataSrc->FrameWidth();
        int imH = mRgbDataSrc->FrameHeight();
            Array2dVec3UInt8* ar =
            new Array2dVec3UInt8(imW, imH, 0, 0, 0, false);
        mRgbDataSrc->GotoFrame(frameNr);
            memcpy( (void *) ar->CPB(0, 0), mRgbDataSrc->DataPtr(), imW*imH*3 );
        return ar;
    }

    virtual void
    HandleNewConcept()
    {
        mNrAnnotated = 0;
        mNrPositive = 0;
        mNrSkip = 0;
        mNrNegative = 0;

        CheckLoadVideoAnnotations();
        CheckLoadMpeg7();
        ConstructShotRanking(!mRankAll);
        HandleNewShot();
    }

    virtual void
    HandleLoadConcepts(String fileName, bool handleNew=true)
    {
        mConceptSet = fileName;
        if (mConceptSet.empty())
            return;
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String fName = mSegDoc->GetVideoSet()->GetFilePath("Annotations",
                                                           mConceptSet,
                                                           false, false);
        if (fName.empty())
        {
            ILOG_ERROR("Can't load concept file");
            return;
        }
        mSegDoc->LoadConcepts(fName);
#else // REPOSITORY_USED
        mSegDoc->LoadConcepts(fileName);
#endif // REPOSITORY_USED
        if (mSegDoc->HasConcepts())
        {
            mSegDoc->SetConcept(0);
            mConceptField->SetText(mSegDoc->GetConcept());
            if (handleNew)
                HandleNewConcept();
        }
    }

    virtual void
    HandleSaveConcepts(String fileName)
    {
        mConceptSet = fileName;
        if (mConceptSet.empty())
            return;
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String fName = mSegDoc->GetVideoSet()->GetFilePath("Annotations",
                                                           mConceptSet,
                                                           true, false);
        if (fName.empty())
        {
            ILOG_ERROR("Can't save concept file");
            return;
        }
        ILOG_INFO("Saving concepts in " << fileName);
        mSegDoc->SaveConcepts(fName);
#else // REPOSITORY_USED
        mSegDoc->SaveConcepts(fileName);
#endif // REPOSITORY_USED
    }

    // Find shot of frame in thresholded shots
    int FindFrameShot(int frame)
    {
        int     i;
        for (i=0; i<mShots.size(); i++)
            if (mShots[i] >= frame)
                return i==0 ? 0 : i-1;
        return -1;
    }

    // Find shot of frame in segmentation document shots
    int FindSegFrameShot(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==firstShot ? i : i-1;
    }

    int FindAdjacentAnnoShot(int curFile, int bit, int shotIdx, bool next)
    {
        if (curFile == -1) return -1;

        Segmentation* seg         = mSegDoc->GetSegmentation();
        int           firstShot   = seg->GetFirstShotVideo(curFile);
        int           sz          = seg->GetNrShotsVideo(curFile);
        int           lastShot    = firstShot+sz;
        int           foundShotNr = -1;

        for (int i=firstShot; i<lastShot; i++)
        {
            int   kFrame   = mKeyframes->GetShotRKF(i);
            int   frame    = mKeyframes->GetFrameNr(kFrame);
            int   val      = (*mVideoAnnotations[curFile])[i-firstShot];
            bool  unknown  = (val == 0);
            bool  skipped  = (val == SKIPPED_BIT);
            bool  positive = (val == POSITIVE_BIT);
            bool  negative = (val == NEGATIVE_BIT);
            bool  passTest = ((bit==POSITIVE_BIT) && positive ||
                             (bit==NEGATIVE_BIT) && negative ||
                             (bit==SKIPPED_BIT)  && skipped  ||
                             (bit==UNKNOWN_BIT)  && unknown);
            if (passTest && next && i > shotIdx)
                return i;
            if (i!=shotIdx && passTest && !next)
                foundShotNr = i;
            if (!next && i>=shotIdx)
                return foundShotNr;
        }
        return foundShotNr;
    }

    int FindAdjacentAnnoShot(int bit, int shotIdx, bool next)
    {
        return FindAdjacentAnnoShot(mCurFile,bit,shotIdx,next);
    }

    bool GoToAdjacentAnnoShot(int bit, int shotIdx, bool next)
    {
        int shot;
        if ((shot=FindAdjacentAnnoShot(bit,shotIdx,next))==-1)
            return false;
        mSegDoc->GotoShot(shot);
        AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
        return true;
    }

    int FindNextAnno(int bit, bool next, bool stayInVideo)
    {
        Segmentation* seg        = mSegDoc->GetSegmentation();
        int           nrVideos   = seg->GetNrVideos();
        int           curShot    = mSegDoc->CurShot();
        int           curFile    = mCurFile;
curFile = mSegDoc->CurFileId();
        int           shot;

        if ((shot=FindAdjacentAnnoShot(curFile,bit,curShot,next))!=-1)
            return curFile * 100000 + shot;
        if (stayInVideo)
            return -1;

        if (next) while (++curFile < nrVideos)
        {
            int firstShot = seg->GetFirstShotVideo(curFile);
            if ((shot = FindAdjacentAnnoShot(curFile,bit,firstShot-1,true))!=-1)
                return curFile * 100000 + shot;
        }
        else while(--curFile >= 0)
        {
            int firstShot = seg->GetFirstShotVideo(curFile);
            int lastShot = firstShot+seg->GetNrShotsVideo(curFile);
            if ((shot = FindAdjacentAnnoShot(curFile,bit,lastShot,false))!=-1)
                return curFile * 100000 + shot;
        }
        return -1;
    }

    void GoToNextAnno(int bit, bool next, bool stayInVideo)
    {
        int res = FindNextAnno(bit,next,stayInVideo);
        if (res != -1)
        {
            AllHandleNewCursor(mSegDoc->CursorToFile(res/100000),false);
            mSegDoc->GotoShot(res%100000);
            AllHandleNewCursor(Core::Database::LEVEL_SHOT,false);
        }
    }


    void Synchronize(int kf=-1)
    {
        if (kf==-1) kf = 0;
        int frame = mSimTLV ? mSimTLV->Player()->FrameNr() : kf;
        int shot = FindSegFrameShot(frame);
        int kFrame = mKeyframes->GetShotRKF(shot);
        mSegDoc->GotoKeyfr(kFrame);
        AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
    }

    // Shot boundary editing
    void AdjustAnnoBoundary(int lData)
    {
        int frame = mSimTLV->Player()->FrameNr();
        int lFrame, rFrame;
        int kFrame = ((mCurKey!=-1) ? mKeyframes->GetFrameNr(mCurKey) : 0);

        mShotValueSB->GetMinMaxValue(lFrame, rFrame);
        if (lData==BUT_LEFT_SHOT)
            FillShotSample(frame, rFrame, kFrame);
        else
            FillShotSample(lFrame, frame, kFrame);
    }

    void SetRankingMode(bool mode)
    {
        mRankingMode = mSimSet ? mode : false;
        mNavModeBtn->SetText(mRankingMode ? "R" : "S");
        PrevNextAnnoControlFeedBack();
    }

    void GoToCurrentRank()
    {
        if (mRankedShots.size())
        {
            mSegDoc->GotoShot(mRankedShots[mCurRankShot]);
            AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
        }
    }

    void ToggleNavigationMode()
    {
        SetRankingMode(mNavModeBtn->GetText() == "S");
        if (mRankingMode)
            GoToCurrentRank();
    }

    void NavigateExtremes(bool toStart)
    {
        int shot = 0;

        if (mRankingMode && mRankedShots.size())
        {
            if ((mCurRankShot = toStart ? 0 : mRankedShots.size()-1)!=-1)
                shot = mRankedShots[mCurRankShot];
        }
        else
        {
            Segmentation* seg = mSegDoc->GetSegmentation();
            shot =  seg->GetFirstShotVideo(mCurFile);
            if (!toStart)
                shot += seg->GetNrShotsVideo(mCurFile)-1;
        }
        mSegDoc->GotoShot(shot);
        AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
    }

// Event handling stuff
    virtual void
    ButtonSelectionEvent(Button* src, void* vData)
    {
        DataDocumentGui<SegmentationDocument>::ButtonSelectionEvent(src, vData);
        int lData = (int)((long long) vData);
        switch (lData)
        {
        case BUT_POSITIVE:
            DoAnno(1,false);
            break;
        case BUT_SKIP:
            DoAnno(0.5,false);
            break;
        case BUT_NEGATIVE:
            DoAnno(0,false);
            break;
        case BUT_SHOT_POS:
            DoAnno(1,true);
            break;
        case BUT_SHOT_NEG:
            DoAnno(0,true);
            break;
        case BUT_NAV_MODE:
            ToggleNavigationMode();
            break;
        case BUT_NAV_BEGIN:
        case BUT_NAV_END:
            NavigateExtremes(lData==BUT_NAV_BEGIN);
            break;
        case BUT_BACK:
            GoBack();
            break;
        case BUT_FORW:
            GoForw(true);
            break;
        case BUT_SAVE:
            CheckSaveMpeg7(false);
            break;
        case BUT_SYNC:
            Synchronize();
            break;
        case BUT_LEFT_SHOT:
        case BUT_RIGHT_SHOT:
            AdjustAnnoBoundary(lData);
            break;
        case VIEWSTRIP_PRE:
        case VIEWSTRIP_MIN:
        case VIEWSTRIP_MAX:
            mSimTLV->TimeLine()->ViewStripZoomToShowViews(lData-VIEWSTRIP_PRE);
        break;
        case BUT_RANK_ALL:
        case BUT_RANK_NOT_ANN:
            ConstructShotRanking(lData==BUT_RANK_NOT_ANN);
            SetRankingMode(true);
            if (mRankingMode)
                GoToCurrentRank();
        break;
/*
        case 1234:
            HandlePUNS();
        break;
*/
        } // end switch
        
    }
    virtual void
    HandleNewKey(int c, int state)
    {
        ILOG_DEBUG("HandleNewKey: " << c);
        if (CheckBinding("annoPositive",c,state))
            DoAnno(1,false);
        if (CheckBinding("annoSkip",c,state))
            DoAnno(0.5,false);
        if (CheckBinding("annoNegative",c,state))
            DoAnno(0,false);
        if (CheckBinding("annoShotPositive",c,state))
            DoAnno(1,true);
        if (CheckBinding("annoShotNegative",c,state))
            DoAnno(0,true);
        if (CheckBinding("annoBackward",c,state) || (mRankingMode && c==oglLEFT))
            GoBack();
        if (CheckBinding("annoForward",c,state) || (mRankingMode && c==oglRIGHT))
            GoForw(true);
        if (c == oglHOME || c == oglEND)
            NavigateExtremes(c==oglHOME);
        if (CheckBinding("annoTogglePlay",c,state) && mSimTLV)
        {
            if (mSimTLV->Player()->Playing())
                mSimTLV->Player()->Stop();
            else
                mSimTLV->Player()->Play();
        }
        if (c == 8 || c == 127)
        {
            if (mAnnoHistoryVSB)
                mAnnoHistoryVSB->SBar()->ChangePos((state&oglControl)?1:-1);
            else
                OnAnnoHistoryVSB(mAnnoHistoryPos + ((c==8) ? -1 : 1));
        }
    }

    void OnAnnoHistoryVSB(int value)
    {
        int sz = mAnnoHistory.size();
        if (value < 0 || value > sz || sz==0)
            return;
        bool goForward = (value == sz);
        mAnnoHistoryPos = value -= goForward ? 1 : 0;
        mDataDoc->CursorToFile(mAnnoHistory[value].fileIdx);
        AllHandleNewCursor(Core::Database::LEVEL_FILE, false);
        if (mSimTLV)
            mSimTLV->Player()->GotoFrame(mAnnoHistory[value].frameIdx);
        mCurRankShot = mAnnoHistory[value].rankIdx;
        Synchronize(mAnnoHistory[value].frameIdx);
        if (goForward)
            GoForw(false);
    }

    virtual void
    UpDownButtonSelectionEvent(UpDownButton *src, bool isUpBtn, void* userData)
    {
        int updownBut = (long long) userData;
        int bit = 0;
        if (updownBut == UPDOWNBUT_POSITIVE)
            bit = POSITIVE_BIT;
        else if (updownBut == UPDOWNBUT_SKIPPED)
            bit = SKIPPED_BIT;
        else if (updownBut == UPDOWNBUT_NEGATIVE)
            bit = NEGATIVE_BIT;
        else if (updownBut == UPDOWNBUT_UNKNOWN)
            bit = UNKNOWN_BIT;
        if (bit)
            GoToNextAnno(bit, isUpBtn, mPrevNextAnnoStayInVideo);
    }

    virtual void
    UpDownNumberChangedEvent(UpDownNumber *src, void* userData)
    {
        if (src == mStepUpDown)
            mStepSize = src->GetValue();
        if (src == mShotThresholdUDNr)
        {
            mShotThreshold = src->Value();
            ConstructShots(mShotThreshold);
            HandleNewShot(); // To recompute present values
        }
    }

    virtual void
    OnValueChanged(ValueScrollBar *src, int value, void* userData)
    {
        if (mSimTLV && src == mShotValueSB && !mShotValueSBAdjusting)
            mSimTLV->Player()->GotoFrame(value);
        if (src == mRankVSB && !mRankVSBAdjusting)
        {
            mCurRankShot = value;
            GoToCurrentRank();
        }
        if (src == mAnnoHistoryVSB && !mAnnoHistoryVSBAdjusting)
            OnAnnoHistoryVSB(value);
    }

    virtual void
    CheckBoxEvent(CheckBox *src, bool checked, void* vData)
    {
        int userData = (long long) vData;

        if (userData == CHBOX_RANK_MODE)
        {
            SetRankingMode(checked);
            GoToCurrentRank();
        }
        if (userData == CHBOX_SHOW_THRESH_SHOTS)
            mShowThreshShots = checked;
        if (userData == CHBOX_SHOW_SEG_SHOTS)
            mShowSegShots = checked;
        if (userData == CHBOX_PN_IN_VIDEO)
            mPrevNextAnnoStayInVideo = checked;
    }
// End of event handling stuff

// Feedback stuff
    void DrawFramesLine(SimilarityTimeLine* sTL, int f1,int f2, int w,
                        int y1, int y2, ULONG col)
    {
        if (!sTL)
            return;
        int fPix = sTL->Unit2Pixel(f1*40);
        int lPix = sTL->Unit2Pixel(f2*40);
        if (fPix == lPix && y1 == y2)
            lPix += 1;
        SetLineWidth(w);
        SetSolidLineColor(col);
        DrawLine(fPix, y1, lPix, y2);
        SetLineWidth(1);
    }

    void
    DisplayThreshShots(SimilarityTimeLine* sTL, int y, ULONG col1, ULONG col2)
    {
        if (!sTL)
            return;
        int fVisFr   = sTL->FirstVisibleFrame();
        int lVisFr   = sTL->LastVisibleFrame();
        int fVisShot = FindFrameShot(fVisFr);
        int lVisShot = FindFrameShot(lVisFr);
        for (int i = fVisShot; i<lVisShot+1 && i<mShots.size()-1; i++)
        {
            int fFrame = mShots[i]+1;
            int lFrame = mShots[i+1];
            DrawFramesLine(sTL,fFrame,lFrame,2,y,y,(i%2) ? col1 : col2);
        }
    }

    void
    DisplaySegShots(SimilarityTimeLine* sTL, int y, ULONG col1, ULONG col2)
    {
        Segmentation* seg = mSegDoc->GetSegmentation();
        if (!seg || !sTL)
            return;

        int fVisFr    = sTL->FirstVisibleFrame();
        int lVisFr    = sTL->LastVisibleFrame();
        int firstShot = seg->GetFirstShotVideo(mCurFile);
        int lastShot  = firstShot+seg->GetNrShotsVideo(mCurFile);
        int fVisShot  = FindSegFrameShot(fVisFr);
        int lVisShot  = FindSegFrameShot(lVisFr);

        for (int i = fVisShot; i<lVisShot+1 && i<lastShot; i++)
        {
            int fFrame = seg->GetStart(i);
            int lFrame = seg->GetEnd(i);
            DrawFramesLine(sTL,fFrame,lFrame,2,y,y,(i%2) ? col1 : col2);
        }
    }

    void
    DisplayShotRelevances(SimilarityTimeLine* sTL, int y)
    {
        Segmentation* seg = mSegDoc->GetSegmentation();
        if (!seg || !sTL || !mCurMpeg7)
            return;

        int fVisFr    = sTL->FirstVisibleFrame();
        int lVisFr    = sTL->LastVisibleFrame();
        int firstShot = seg->GetFirstShotVideo(mCurFile);
        int lastShot  = firstShot+seg->GetNrShotsVideo(mCurFile);
        int fVisShot  = FindSegFrameShot(fVisFr);
        int lVisShot  = FindSegFrameShot(lVisFr);

        for (int i = fVisShot; i<lVisShot+1 && i<lastShot-1; i++)
        {
            int fFrame = seg->GetStart(i);
            int idx = mCurMpeg7->FindShot(fFrame+1);
            DrawShotRelevance(sTL, idx, -1, y);
        }
    }

    void ShotControlFeedback(int fFrame, int lFrame, int kFrame)
    {
        if (!mSimTLV || !mShotValueSB)
            return;
        // Feedback for Shot Scrollbar
        int playFrame = mSimTLV->Player()->FrameNr();
        mShotValueSBAdjusting = true;
        mShotValueSB->SetValue(playFrame);
        mShotValueSBAdjusting = false;
        mShotValueSB->SBar()->ButDecr()
            ->SetBorderBackground((playFrame<fFrame) ? oglRED : 0);
        mShotValueSB->SBar()->ButIncr()
            ->SetBorderBackground((playFrame>lFrame) ? oglRED : 0);
        // Feedback for adjust shot boundaries
        if (!mNoShotEditing)
        {
            mShotLeftBtn ->SetState(((playFrame<kFrame) && mSimTLV) ? 1 : 0); 
            mShotRightBtn->SetState(((playFrame>kFrame) && mSimTLV) ? 1 : 0);
        }
    }

    // Feedback for ranking options and scrollbar
    void RankingControlFeedback()
    {
        if (mRankVSB)
        {
            if (mRankingMode)
            {
                mRankVSBAdjusting = true;
                mRankVSB->SetValue(mCurRankShot);
                mRankVSBAdjusting = false;
            }
            mRankVSB->SBar()->SetState(mRankingMode ? 1 : 0);
            mRankVSB->ValText()->SetState(mRankingMode ? 1 : 0);
        }
        mRankChBox->SetState(mSimSet?1:0);
        mRankChBox->SetSelected(mRankingMode);
        mRankAllBtn->SetBorderBackground(mRankAll?oglTrLIGHTGREEN:0);
        mRankNotAnnoBtn->SetBorderBackground(mRankAll?0:oglTrLIGHTGREEN);
    }

    void HandleUpDownState(UpDownButton* udBtn, int state, bool doParent=false)
    {
        udBtn->UpButton()->SetState(state);
        udBtn->DownButton()->SetState(state);
        udBtn->SetState(state);
        if (doParent)
            udBtn->GetParent()->SetState(state);
    }

    void PrevNextAnnoControlFeedBack()
    {
        if (mNoPrevNextControl)
            return;
        int state = !mRankingMode;
        HandleUpDownState(mPositiveUDBtn,state,true);
        HandleUpDownState(mSkippedUDBtn,state,true);
        HandleUpDownState(mNegativeUDBtn,state,true);
        HandleUpDownState(mUnknownUDBtn,state,true);
    }

    void DrawShotRelevance(SimilarityTimeLine* sTL, int idx, int kFrame, int y)
    {
        if (idx == -1 || !mCurMpeg7)
            return;
        float relevance = mCurMpeg7->Relevance(idx);
        ULONG col = RelevanceColor(relevance);
        int fFrame = mCurMpeg7->StartFrame(idx);
        int lFrame = mCurMpeg7->EndFrame(idx);
        DrawFramesLine(sTL, fFrame, lFrame, 2, y, y, col);
        if (kFrame != -1)
            DrawFramesLine(sTL, kFrame, kFrame, 1, y, y-6, col);
    }

    // Called when the SimTimeLineVideo is displayed
    virtual void WindowDisplayEvent(OglGui::Window *src, void* userData)
    {
        SimilarityTimeLine* sTL = (SimilarityTimeLine*) src;
        int y                   = sTL->GetAxisY();
        int kFrame              = mKeyframes->GetFrameNr(mCurKey);
        int fFrame              = -1;
        int lFrame              = -1;

        // Draw line between shot boundaries
        if (!mCurShotFrames.empty())
        {
            fFrame = mCurShotFrames[0];
            lFrame = mCurShotFrames[mCurShotFrames.size()-1];
            DrawFramesLine(sTL, fFrame, lFrame, 2, y-18, y-18, 0xffffff00);
        }

        ShotControlFeedback(fFrame,lFrame,kFrame);
        if (mShowThreshShots)
            DisplayThreshShots(sTL, y-24,0xff808000, 0xffb0b000);
        if (mShowSegShots)
            DisplaySegShots(sTL,y-27,0xffb0b0ff,0xff8080ff);
        if (mCurMpeg7)
        {
               int idx = mCurMpeg7->FindShot(kFrame);
               DrawShotRelevance(sTL, idx, kFrame, y-20);
        }
    }

    virtual void DisplayFunc()
    {
        DataDocumentGui<Core::VideoSet::SegmentationDocument>::DisplayFunc();

        char buf[100];
        sprintf(buf, "NrAnno: %d Pos %d Skip %d Neg %d V(%d)", mNrAnnotated,
                mNrPositive, mNrSkip, mNrNegative, mNrAnnoPerVideo);
        mNrAnnoTxt->SetText(buf);
        RankingControlFeedback();
    }
// End of feedback stuff

private:

    int Relevance2Bit(float rel)
    {
        if (rel < 0.01)
            return NEGATIVE_BIT;
        if (rel > 0.99)
            return POSITIVE_BIT;
        else
            return SKIPPED_BIT;
    }

    void RelevanceStats(double rel, int delta)
    {
        if (rel < 0.01)
            mNrNegative += delta;
        else if (rel > 0.99)
            mNrPositive += delta;
        else
            mNrSkip += delta;
    }

    void AnnoStats(int idx, double relevance)
    {
        if (idx == -1)
        {
            mNrAnnoPerVideo++;
            mNrAnnotated++;
        }
        RelevanceStats(relevance,1);
    }

    bool InAnnoHistory(AnnoHistory* aH)
    {
        for (int i=0; i<mAnnoHistory.size(); i++)
        {
            AnnoHistory *annoH = &mAnnoHistory[i];
            if (annoH->fileIdx == aH->fileIdx &&
                annoH->frameIdx == aH->frameIdx &&
                annoH->rankIdx == aH->rankIdx
               )
                return true;
        }
        return false;
    }

    void ToAnnoHistory(int fileIdx, int frameIdx, int rankIdx)
    {
        AnnoHistory annoHist = {fileIdx, frameIdx, rankIdx};
        if (!InAnnoHistory(&annoHist))
        {
            mAnnoHistory.push_back(annoHist);
            mAnnoHistoryPos = mAnnoHistory.size();
            if (!mAnnoHistoryVSB)
                return;
            mAnnoHistoryVSBAdjusting = true;
            mAnnoHistoryVSB->SetMinMaxValue(0,mAnnoHistoryPos);
            mAnnoHistoryVSB->SetValue(mAnnoHistoryPos);
            mAnnoHistoryVSBAdjusting = false;
        }
    }

    bool CheckAnnoMax()
    {
        Segmentation* seg       = mSegDoc->GetSegmentation();
        int           firstShot = seg->GetFirstShotVideo(mCurFile);

        bool annoMax = mNrAnnoPerVideo >= mMaxAnnoPerVideo ||
                       FindAdjacentAnnoShot(UNKNOWN_BIT,firstShot-1,true)==-1;
        if (annoMax && mRankingMode && !mNoAutoNextAnno)
        {
                        mCurFile;
                        if (!mSegDoc->GotoNextVideo())
                                return true;
                        mCurFile;
                        //mCurFile = mSegDoc->CurFileId();
            int res = FindNextAnno(UNKNOWN_BIT, true, false);
            if (res != -1)
                AllHandleNewCursor(mSegDoc->CursorToFile(res/100000),false);
        }
        return annoMax;
    }

    void DoAnno(double relevance, bool isShot)
    {
        if (!mSegDoc->HasCurShot() || !mCurMpeg7)
            return;
        String  name      = FileNameBase(mKeyframes->GetName(mCurKey));
        int     frameNr   = mKeyframes->GetFrameNr(mCurKey);
        bool    empty     = mCurShotFrames.empty();
        int     sz        = mCurShotFrames.size();
        int     shotStart = (empty||!isShot) ? frameNr : mCurShotFrames[0];
        int     shotEnd   = (empty||!isShot) ? frameNr : mCurShotFrames[sz-1];

        int oldIdx = mCurMpeg7->FindShot(frameNr);
        if (oldIdx!=-1)
            RelevanceStats(mCurMpeg7->Relevance(oldIdx),-1);

        char buf[80];
        sprintf(buf, "%s_frame%d_%d", name.c_str(),shotStart,shotEnd);
        int idx = mCurMpeg7->ReplaceAnnotationEx(mSegDoc->GetConcept(),
                                                 isShot?buf:name,
                                                 frameNr,shotStart,
                                                 shotEnd,relevance,1);

        Segmentation* seg = mSegDoc->GetSegmentation();
        int shot = FindSegFrameShot(frameNr) - seg->GetFirstShotVideo(mCurFile);
        (*mVideoAnnotations[mCurFile])[shot] = Relevance2Bit(relevance); 

        mCurMpeg7Changed = true;
        ToAnnoHistory(mCurFile, frameNr, mCurRankShot);
        AnnoStats(idx, relevance);
        UpdateRelevance();
        if (!CheckAnnoMax() || !mRankingMode)
            GoForw(false);
    }

    void
    GoBack()
    {
        if (mRankingMode)
        {
            if (!mRankedShots.size())
                return;
            if ((mCurRankShot-=mStepSize) < 0)
                mCurRankShot = 0;
            int newShot = mRankedShots[mCurRankShot];
            if (newShot != mSegDoc->CurShot())
            {
                mSegDoc->GotoShot(newShot);
                return AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
            }
        }
        else if (mSegDoc->GotoPrevShot(mStepSize))
            return AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
    }

    void
    GoForw(bool withinVideo)
    {
        if (mRankingMode)
        {
            int sz = mRankedShots.size();
            mCurRankShot += mStepSize;
            if (mCurRankShot > sz-1)
            {
                mCurRankShot = sz ? sz-1 : 0;
                if (!withinVideo && mSegDoc->GotoNextVideo())
                    return AllHandleNewCursor(Core::Database::LEVEL_FILE,false);
            }
            if (mCurRankShot >= 0 && mCurRankShot < sz)
            {
                int newShot = mRankedShots[mCurRankShot];
                if (newShot != mSegDoc->CurShot())
                {
                    mSegDoc->GotoShot(newShot);
                    return AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
                }
            }
            CheckSaveMpeg7(false);
            return;
        }
        if (mSegDoc->GotoNextShot(mStepSize))
            return AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
        if (withinVideo)
            return;
        if (mSegDoc->GotoNextVideo())
            return AllHandleNewCursor(Core::Database::LEVEL_FILE, false);
        CheckSaveMpeg7(false);
    }

    void
    UpdateRelevance()
    {
                if (!mCurMpeg7)
                        return;
        int frame = mKeyframes->GetFrameNr(mCurKey);
        int idx = mCurMpeg7->FindShot(frame);
        mCurRelevance = (idx == -1) ? 0.5 : mCurMpeg7->Relevance(idx);
        String typeString;
        if (mCurRelevance < 0.01)
            typeString = "negative";
        else if (mCurRelevance > 0.99)
            typeString = "positive";
        else
            typeString = "skip";
         if (idx == -1)
             typeString = "unknown";

        bool isShot = false;
        if (idx != -1 && mCurShotFrames.size() != 0)
        {
            int fFrame = mCurMpeg7->StartFrame(idx);
            int lFrame = mCurMpeg7->EndFrame(idx);
            if (fFrame != lFrame)
                isShot = true;
        }
        mShotText->SetTextColor(isShot?RelevanceColor(mCurRelevance):oglBLACK);
        mImShotWnd->SetBorderBackground(isShot?RelevanceColor(mCurRelevance):0);
        mFrameText->SetTextColor(RelevanceColor(mCurRelevance));
        mShotText->SetText("shot " + (isShot ? typeString : "unknown"));
        mFrameText->SetText(isShot ? "" : ("fr " + typeString));
    }

    ULONG RelevanceColor(float relevance)
    {
        if (relevance < 0.01)
            return oglTrRED;
        if (relevance > 0.99)
            return oglTrDARKGREEN;
        return oglBLACK;
    }

    void
    CheckLoadMpeg7()
    {
        if ((mCurFile == mSegDoc->CurFileId()) &&
            (mCurConcept == mSegDoc->GetConceptIdx()))
        {
            return;
        }
        CheckSaveMpeg7(true);
        mCurFile = mSegDoc->CurFileId();
        mCurConcept = mSegDoc->GetConceptIdx();
        if ((mCurFile == -1) || (mCurConcept == -1))
            return;
        String vidName = mVidSet->GetFile(mCurFile);
        String concept = mSegDoc->GetConcept();
        // ILOG_INFO("Loading " << concept << " for " << vidName);
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String fName = mVidSet->GetFilePathMpeg7Anno(mCurFile,mConceptSet,
                                                     concept+".xml",false,true);
        if (fName.empty())
        {
            int nrFr = mSegDoc->GetSegmentation()->GetNrFramesVideo(mCurFile);
            int fractions = 25; // todo: derive from video data
                        mConceptSet;
            mCurMpeg7 = new Mpeg7Doc(vidName, vidName, nrFr, fractions, false,
                                     mConceptSet, concept);
        }
        else
        {
            mCurMpeg7 = new Mpeg7Doc(fName, mVidSet->GetDatabase());
            mCurMpeg7->SetConceptSet(mConceptSet);
        }
#else // REPOSITORY_USED
        String container = mConceptSet + "/" + mVidSet->GetContainerFile(mCurFile);
        typedef Persistency::Mpeg7DocLocator MP7Loc;
        MP7Loc loc(mVidSet->GetLocator(), MP7Loc::MPEG7_ANNOTATION, container,
                   concept + ".xml");
        if (!Persistency::Mpeg7DocRepository().Exists(loc))
        {
            int nrFr = mSegDoc->GetSegmentation()->GetNrFramesVideo(mCurFile);
            int fractions = 25; // todo: derive from video data
                        mConceptSet;
            mCurMpeg7 = new Mpeg7Doc(vidName, vidName, nrFr, fractions, false,
                                     mConceptSet, concept);
        }
        else
        {
            mCurMpeg7 = Persistency::Mpeg7DocRepository().Get(loc);
            mCurMpeg7->SetConceptSet(mConceptSet);
        }
#endif // REPOSITORY_USED
    }

    void
    CheckSaveMpeg7(bool doDelete)
    {
        if (mCurMpeg7 && mCurMpeg7Changed)
        {
            ILOG_INFO("Saving " << mSegDoc->GetConcept(mCurConcept) << " for "
                      << mVidSet->GetFile(mCurFile));
            Core::VideoSet::Mpeg7DocWrite(mCurMpeg7, mSegDoc->GetVideoSet(),
                                          mCurFile);
            if (doDelete)
            {
                delete mCurMpeg7;
                mCurMpeg7 = 0;
            }
        }
        mCurMpeg7Changed = false;
    }

    void ClearVideoAnnotations()
    {
        for (int i = mVideoAnnotations.size()-1; i>=0; i--)
            delete mVideoAnnotations[i];
        mVideoAnnotations.clear();
    }

    void CheckLoadVideoAnnotations()
    {
        int oldCurFile      = mCurFile;
        int conceptIdx      = mSegDoc->GetConceptIdx();

        if (conceptIdx == -1 || conceptIdx == mCurConcept)
            return;
        ClearVideoAnnotations();
        Segmentation* seg = mSegDoc->GetSegmentation();
        int nrVideos = seg->GetNrVideos();

        ILOG_INFO("Reading Mpeg7 video annotations for concept "
                  + mSegDoc->GetConcept(conceptIdx));
        mSegDoc->CursorToDir(0);
        do {
            CheckLoadMpeg7();
            printf("Video annotation %d of %d   \r",mCurFile,nrVideos);
            int firstShot   = seg->GetFirstShotVideo(mCurFile);
            int sz          = seg->GetNrShotsVideo(mCurFile);
            int lastShot    = firstShot+sz;
            VideoAnnotation* vidAnno = new VideoAnnotation(sz);
            mVideoAnnotations.push_back(vidAnno);
            for (int i=firstShot; i<lastShot; i++)
            {
                int   kFrame   = mKeyframes->GetShotRKF(i);
                int   frame    = mKeyframes->GetFrameNr(kFrame);
                int   idx      = mCurMpeg7->FindShot(frame);
                bool  unknown  = (idx==-1);
                float rel      = unknown ? 0.5 : mCurMpeg7->Relevance(idx);
                bool  positive = rel > 0.99;
                bool  negative = rel < 0.01;
                bool  skipped  = !unknown && !positive && !negative;
                if (skipped)
                    (*vidAnno)[i-firstShot] = SKIPPED_BIT;
                if (positive)
                    (*vidAnno)[i-firstShot] = POSITIVE_BIT;
                if (negative)
                    (*vidAnno)[i-firstShot] = NEGATIVE_BIT;
            }
        } while (mSegDoc->CursorNextFile());
        mCurFile = -1;
        AllHandleNewCursor(mSegDoc->CursorToFile(oldCurFile), false);
    }

    void CheckNewVideo(int oldCurFile)
    {
        if (mRgbDataSrc && oldCurFile == mSegDoc->CurFileId())
            return;

        mNrAnnoPerVideo = 0;
        mCurFile = mSegDoc->CurFileId();

        ConstructNewVideoSimSet();

        if (mRgbDataSrc)
            delete mRgbDataSrc;
        mRgbDataSrc = 0;

        Core::Database::RawDataSet* dataSet = mSegDoc->GetDataSet();
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String videoName =
            dataSet->GetFilePathVideoData(mCurFile,false,false);
        String rawName =
            dataSet->GetFilePathFrames(mCurFile,"images_jpg.raw",false,false);
        mRgbDataSrc = OpenRgbDataSrc(rawName, videoName);
#else // REPOSITORY_USED
        ILOG_ERROR("Todo : CheckNewVideo");
        String videoName;
        String rawName;
#endif // REPOSITORY_USED

        if (!mSimTLV && !mNoSimTLV && mShotSimSet)
            CreateSimTLV();

        if (mSimTLV && mShotSimSet)
        {
            RgbDataSrc *rgbDataSrc = OpenRgbDataSrc(rawName, videoName);
            mSimTLV->OpenVideo(rgbDataSrc, videoName);
            mSimTLV->TimeLine()->DocW(4*rgbDataSrc->LastFrame());
            mSimTLV->SetSimilarityTableSet(mShotSimSet);
            rgbDataSrc = OpenRgbDataSrc(rawName, videoName);
            mSimTLV->TimeLine()->ViewStripRgbDataSrc(rgbDataSrc);
            mSimTLV->TimeLine()->ViewStripShow(true);
        }
        ConstructShots(mShotThreshold);
        mCurRankShot = 0;
        if (mRankingMode && !mNoAutoNextAnno)
            GoToCurrentRank();
        else
            HandleNewShot();
    }

    RgbDataSrc* OpenRgbDataSrc(String rawName, String videoName)
    {
        RgbDataSrc *rgbDataSrc = 0;
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        if (!rawName.empty())
            rgbDataSrc = new RgbDataSrcRaw(rawName);
        else if (!videoName.empty())
        {
            RgbDataSrcFactory& f = RgbDataSrcFactory::Instance();
            rgbDataSrc = f.Construct(RgbDataSrcFactory::SRC_LAVC_WITHIDX,
                                     videoName, mVidSet->GetDatabase());
        }
#else // REPOSITORY_USED
        ILOG_ERROR("Todo : OpenRgbDataSrc");
#endif // REPOSITORY_USED

        if (!rgbDataSrc || !rgbDataSrc->Valid())
        {
            ILOG_ERROR("Opening RgbDataSrc failed");
            if (rgbDataSrc)
                delete rgbDataSrc;
            return 0;
            }
        return rgbDataSrc;
    }

    void ConstructShots(float threshold)
    {
        mShots.clear();
        mShots.push_back(-1);
        SimTableType* simTable  = mShotSimSet->GetSimTable(0);
        int sz = simTable->Size();
        for (int i=0; i<sz; i++)
        {
            if (simTable->Get1(i) > threshold)
                mShots.push_back(i);
        }
        if (mShots[mShots.size()-1] != sz-1)
            mShots.push_back(sz-1);
    }

    void CreateSimTLV()
    {
        OglGui::TitledWindow*
            tWnd = new TitledWindow(this,2,0,W()-4,396,"TimeLineVideo");
        mSimTLV = new SimilarityTimeLineVideo(tWnd->ContentPane(),0,0,
                                              W()-10,364, mShotSimSet,15);
        mSimTLV->TimeLine()->SetWindowListener(this);
        mSimTLV->TimeLine()->ShowClassify(false);
        mSimTLV->TimeLine()->SetSimColor(0,0xffffff00);
        mSimTLV->TimeLine()->CurrentViewOnTop(2);
        mSimTLV->TimeLine()->ViewStripMinViewWidth(12);
        mSimTLV->ScaleChildren();
        tWnd->ContentPane()->ScaleChildren();

        StaticText* TBar = mSimTLV->TitledTimeLine()->TitleText();
        new Strut(TBar,160,1);
        // Synchronize with nearest shot
        mSyncBtn = new Button(TBar, 50, 21, "Sync", 4, true);
        mSyncBtn->SetButtonListener(this, BUT_SYNC);
        // Frame Sliding Animation
        mAllowSlidingChBox =
            new CheckBox( TBar, 70, 21, "Sliding", true, 4);
        if (!mNoViewStripControl)
        {
            // ViewStrip Options
            StaticText* vStripTxt =
                new StaticText(TBar,160,21,"ViewStrip",false,true);
            vStripTxt->SetBorderType(BEV_ETCHED);
            InBoxButton(vStripTxt,62,32,"Pre",VIEWSTRIP_PRE);
            InBoxButton(vStripTxt,94,32,"Min",VIEWSTRIP_MIN);
            InBoxButton(vStripTxt,126,32,"Max",VIEWSTRIP_MAX);
        }
        new Strut(TBar,10,1);
        RectCheckBox(TBar,150,21,"Show Seg Shots",
                     CHBOX_SHOW_SEG_SHOTS); 
        RectCheckBox(TBar,160,21,"Show Thresh Shots",
                     CHBOX_SHOW_THRESH_SHOTS);
    }

    void ConstructNewVideoSimSet()
    {
        Core::Database::RawDataSet* dataSet = mSegDoc->GetDataSet();
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        Util::Database* db = dataSet->GetDatabase();

        String simNames =
            dataSet->GetFilePathSimilarityData("Frames", "streamConcepts.txt",
                                               "no_model", "direct", mCurFile,
                                               "names.txt", false, false);
        if (mShotSimSet)
            delete mShotSimSet;
        mShotSimSet = SimilarityTableSet::MakeFromFile(simNames, db);

        // Obtain ranking similarities. Artificial randomizing access in mRankingMode
        simNames = dataSet->GetFilePathSimilarityData
            ("Keyframes",mRankSet,mRankModel,mRankFeature,mCurFile,
             "names.txt",false,false);
        if (mSimSet)
            delete mSimSet;
        mSimSet = 0;
        if (!simNames.empty())
            mSimSet = SimilarityTableSet::MakeFromFile(simNames, db);
#else // REPOSITORY_USED
        typedef Persistency::SimilarityTableSetLocator SimLoc;
        SimLoc loc(dataSet->GetLocator(), false, "Frames", "streamConcepts.txt",
                   "no_model", "direct", dataSet->GetContainerFile(mCurFile));
        if (mShotSimSet)
            delete mShotSimSet;
        mShotSimSet = Persistency::SimilarityTableSetRepository().Get(loc);

        // Obtain ranking similarities. Artificial randomizing access in mRankingMode
        loc = SimLoc(dataSet->GetLocator(), false, "Keyframes", mRankSet,
                     mRankModel, mRankFeature,
                     dataSet->GetContainerFile(mCurFile));
        if (mSimSet)
            delete mSimSet;
        mSimSet = 0;
        mSimSet = Persistency::SimilarityTableSetRepository().Get(loc);
#endif // REPOSITORY_USED
        ConstructShotRanking(!mRankAll);
    }

    int FindRankedShot(int shot)
    {
        int sz = mRankedShots.size();
        for (int i=0; i<sz; i++)
            if (mRankedShots[i] == shot)
                return i;
        return -1;
    }

    bool PassTest(int filter, bool unKnown, bool pos, bool neg, bool skip)
    {
        if ( ((filter & UNKNOWN_BIT)  && unKnown) ||
             ((filter & POSITIVE_BIT) && pos)     ||
             ((filter & NEGATIVE_BIT) && neg)     ||
             ((filter & SKIPPED_BIT)  && skip)
           )
            return true;
        return false;
    }

    bool ToRankedShots(RankTableType* rankTable, int i, int filter)
    {
        int frame    = QuidId(rankTable->Get1(i));
        int shot     = FindSegFrameShot(frame);
        int firstKey = mKeyframes->GetFirstKeyframeShot(shot);
        int lastKey  = firstKey + mKeyframes->GetNrKeyframesShot(shot);
        int keyfr    = mKeyframes->GetFrameId(frame, firstKey, lastKey);
        if (keyfr==-1 || !mKeyframes->IsRKF(keyfr))
            return false;

        int firstFrame = -1, lastFrame = -1;
        int idx = mCurMpeg7->FindShot(frame);
        if (idx != -1)
        {
            firstFrame = mCurMpeg7->StartFrame(idx);
            lastFrame = mCurMpeg7->EndFrame(idx);
        }
        bool unKnown = (idx == -1);
        float relevance = unKnown ? 0.5 : mCurMpeg7->Relevance(idx);
        bool positive = relevance > 0.99;
        bool negative = relevance < 0.01;
        bool skipped = !unKnown && !positive && !negative;
        if (PassTest(filter,unKnown,positive,negative,skipped))
        {
            if (FindRankedShot(shot) == -1){
                mRankedShots.push_back(shot);
                return true;
            }
        }
        return false;
    }

    void ConstructShotRanking(bool exclAnnotatedMode)
    {
        mRankedShots.clear();
        mCurRankShot = 0;
        mRankAll = !exclAnnotatedMode;

        if (!mSimSet)
            return;

        int tableNr = (mSimSet->NrTables()==1) ? 0 : mCurConcept;
        RankTableType* rankTable = mSimSet->GetRankTable(tableNr);

        int nShots = 0;
        int sz = mSimSet->TableSize();
        for (int i=0; i<sz; i++)
        {
            int filter = exclAnnotatedMode ? UNKNOWN_BIT :
                         UNKNOWN_BIT|POSITIVE_BIT|NEGATIVE_BIT|SKIPPED_BIT;
            if (ToRankedShots(rankTable, i, filter))
                nShots++;
        }
        if (mRankVSB)
            mRankVSB->SetMinMaxValue(0,nShots-1);
    }

    void HandleConceptsFromFile()
    {
        mConceptFileField->SetText(mConceptSet);
        HandleLoadConcepts(mConceptSet, false);

        CmdOptions& options = CmdOptions::GetInstance();
        String conceptStr = options.GetString("concept");
        if (!conceptStr.empty())
        {
            for (int i=0 ; i<mDataDoc->NrConcepts() ; i++)
            {
                if (conceptStr == mDataDoc->GetConcept(i))
                {
                    mDataDoc->SetConcept(i);
                    mConceptField->SetText(mDataDoc->GetConcept());
                    mConceptField->ResetCaret();
                    break;
                }
            }
        }
        if (mDataDoc->GetConceptIdx() != -1)
            HandleNewConcept();
    }

    Button* KbButton(char* str, int w, int h, String keyStr, int userData)
    {
        char buf[40];
        sprintf(buf, "%s (%s)", str, mKeyBindings[keyStr].c_str());

        Button* but = new Button(this,w,h,buf,4,true);
        but->SetButtonListener(this,userData);
        return but;
    }

    UpDownButton*
    PrevNextAnnoShot(OglGui::Window* parent, strconst str, int userData)
    {
        StaticText* txt = new StaticText(parent,50,24,str);
        txt->SetAlign(oglLeftAlign);
        UpDownButton* upDownBtn = new UpDownButton(txt,15,2,36,22,true,2);
        upDownBtn->SetUpDownButtonListener(this, userData);
        upDownBtn->SetBorderType(0);
        upDownBtn->SetRepeatMode(false); // Op duration disturbes repeatmode
        return upDownBtn;
    }

    Button*
    InBoxButton(OglGui::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->SetButtonListener(this,lData);
        btn->ScaleTo(parent);
        btn->SetAllowScaling(false);
        return btn;
    }

    CheckBox*
    RectCheckBox(OglGui::Window* parent, int w, int h,String str,int lData)
    {
        int pW = parent->W();
        int pH = parent->H();
        CheckBox* cb = new CheckBox(parent,w,h,str,false,1);
        cb->SetCheckBoxListener(this,lData);
        cb->SetBoxFrameType(4);
        cb->SetRoundedCheck(false);
        return cb;
    }

    void GuiNavigation()
    {
        Button* but;
                char    buf[40];

        OglGui::Window* navWnd = new OglGui::Window(this,270,24);
        // Navigation mode
        mNavModeBtn = new Button(navWnd,0,0,18,24,"R",4,true);
        mNavModeBtn->SetButtonListener(this,BUT_NAV_MODE);
        // To Start [HOME]
        but = new Button(navWnd,20,0,14, 24,"[",4,true);
        but->SetButtonListener(this,BUT_NAV_BEGIN);
        // Backward
                sprintf(buf,"Backward (%s)", mKeyBindings["annoBackward"].c_str());
        but = new Button(navWnd,34,0,94,24,buf,4,true);
        but->SetButtonListener(this, BUT_BACK);
        but->SetRepeatMode(true);
        // StepSize
        mStepUpDown = new OglGui::UpDownNumber(navWnd,128,0,34,24,1,12,false,0);
        mStepUpDown->SetUpDownNumberListener(this);
        mStepUpDown->SetBorderType(BEV_ETCHED);
        mStepUpDown->SetRange(1,999);
        // Forward
                sprintf(buf,"Forward (%s)", mKeyBindings["annoForward"].c_str());
        but = new Button(navWnd,162,0,94,24,buf,4,true);
        but->SetButtonListener(this, BUT_FORW);
        but->SetRepeatMode(true);
        // To End [END]
        but = new Button(navWnd,256,0,14,24,"]",4,true);
        but->SetButtonListener(this,BUT_NAV_END);
    }

    void GuiVideoShotControl()
    {
        if (mNoSimTLV || mNoShotControl)
            return;

        // Adjust left boundary
        if (!mNoShotEditing)
        {
            mShotLeftBtn = new Button(this,12,24,"|",4,true);
            mShotLeftBtn->SetButtonListener(this, BUT_LEFT_SHOT);
        }
        // Scroll over shot
        mShotValueSB = new ValueScrollBar(this,160,24,0,100,50,2);
        mShotValueSB->SetValueScrollBarListener(this);
        // Adjust right boundary
        if (!mNoShotEditing)
        {
            mShotRightBtn = new Button(this,12,24,"|",4,true);
            mShotRightBtn->SetButtonListener(this, BUT_RIGHT_SHOT);
        }
        if (!mNoShotThreshold)
        {
            // Dynamic shot threshold
            StaticText* sTxt = new StaticText(this, 70, 24, "thr:");
            sTxt->SetAlign(oglLeftAlign);
            mShotThresholdUDNr =
                new UpDownNumber(sTxt,22,0,48,24,0.2f,12,false,0);
            mShotThresholdUDNr->SetUpDownNumberListener(this);
            mShotThresholdUDNr->SetIncrement(0.01f);
            mShotThresholdUDNr->SetBorderType(4);
            mShotThresholdUDNr->SetRange(0.1f,0.6f);
        }
    }

    void GuiRankingControl()
    {
        int sz = mNoRankSlider ? 160 : 290;
        OglGui::Window* rankWnd = new OglGui::Window(this,sz,24);
        // Rank mode
        mRankChBox = new CheckBox(rankWnd,0,0,130,24,"Rank",false,4);
        mRankChBox->SetCheckBoxListener(this, CHBOX_RANK_MODE);
        // Rank all shots including annotated ones
        mRankAllBtn = InBoxButton(mRankChBox,60,32,"All",BUT_RANK_ALL);
        // Rank only shots without annotation
        mRankNotAnnoBtn = InBoxButton(mRankChBox,92,36,"!Ann",BUT_RANK_NOT_ANN);
        if (!mNoRankSlider)        // Ranking scrollbar
        {        
            mRankVSB = new ValueScrollBar(rankWnd,130,0,160,24,0,100,0);
            mRankVSB->SetValueScrollBarListener(this);
        }
    }

    void GuiAnnotationControl()
    {
        Button* but;
        but = new Button(this, 140, 24, "Save Annotation",4,true);
        but->SetButtonListener(this, BUT_SAVE);

        new Strut(this, 4000, 1);
        KbButton("Positive",110,24,"annoPositive",BUT_POSITIVE);
        KbButton("Skip",110,24,"annoSkip",BUT_SKIP);
        KbButton("Negative",110,24,"annoNegative",BUT_NEGATIVE);
        new Strut(this, 100, 1); // Cause newline

        new Strut(this, 16, 1);
        KbButton("Shot Positive",160,24,"annoShotPositive",BUT_SHOT_POS);
        KbButton("Shot Negative",160,24,"annoShotNegative",BUT_SHOT_NEG);
    }

    void GuiAnnoHistoryControl()
    {
        mAnnoHistoryVSB = 0;
        mAnnoHistoryPos = 0;
        if (mNoAnnoHistoryControl)
            return;
        StaticText* txt = new StaticText(this,210,24,"AnnoHistory:");
        txt->SetAlign(oglLeftAlign);
        mAnnoHistoryVSB = new ValueScrollBar(txt,90,0,120,24,0,1,0);
        mAnnoHistoryVSB->SetValueScrollBarListener(this);
    }

    void GuiPrevNextAnnotatedControl()
    {
        if (mNoPrevNextControl)
            return;
        // PrevNextAnno P|S|N|U  (Pos|Neg|Skip|unknown)
        OglGui::Window* prevNextWnd = new OglGui::Window(this,340,24);
        prevNextWnd->SetBorderType(BEV_ETCHED);
        mPNInVideoCB
            = new CheckBox(prevNextWnd,108,22,"StayInVideo",true,0);
        mPNInVideoCB->SetCheckBoxListener(this, CHBOX_PN_IN_VIDEO);
        mPositiveUDBtn = PrevNextAnnoShot(prevNextWnd,"P", UPDOWNBUT_POSITIVE);
        mSkippedUDBtn  = PrevNextAnnoShot(prevNextWnd,"S", UPDOWNBUT_SKIPPED);
        mNegativeUDBtn = PrevNextAnnoShot(prevNextWnd,"N", UPDOWNBUT_NEGATIVE);
        mUnknownUDBtn  = PrevNextAnnoShot(prevNextWnd,"U", UPDOWNBUT_UNKNOWN);
        PrevNextAnnoControlFeedBack();
    }

    void InitGUI()
    {
        GuiName("AnnoControl");
        mNrAnnoTxt =  new StaticText(this,340,22,"NrAnno: ");

        mImWnd = new ImagesWindow(this, 360, 290, true);
        mImWnd->SetViewSize(352,280);

        mImShotWnd = new ImagesWindow(this, W()-380, 290, true);
        mImShotWnd->SetBorderType(BEV_ETCHED);
        mImShotWnd->SetViewSize(176,140);

        GuiNavigation();

        // Relevance texts
        mFrameText  = new TextArea(this, 100, 24, "<empty>",false);
        mShotText   = new TextArea(this, 100, 24, "<empty>",false);

        new Strut(this,1,1);
        GuiVideoShotControl();
        new Strut(this,15,1);
        GuiRankingControl();
        new Strut(this, 20, 1);
        GuiAnnotationControl();
        GuiAnnoHistoryControl();
        GuiPrevNextAnnotatedControl();
        //Button* btn = new Button(this,60,24,"PUNS");
        //btn->SetButtonListener(this,1234);
        HandleConceptsFromFile();
    }

    void ReadKeyBindings()
    {
        InitKeyBinding("annoForward","0");
        InitKeyBinding("annoBackward", "9");
        InitKeyBinding("annoPositive", "1");
        InitKeyBinding("annoSkip", "2");
        InitKeyBinding("annoNegative", "3");
        InitKeyBinding("annoShotPositive", "6");
        InitKeyBinding("annoShotNegative", "7");
        InitKeyBinding("annoTogglePlay", " ");
    }

    void HandleCmdOptions()
    {
        CmdOptions& options = CmdOptions::GetInstance();
        mConceptFeature = options.GetString("conceptFeature");
        mConceptModel = options.GetString("conceptModel");
        mRankSet = options.GetString("rankSet");
        mRankFeature = options.GetString("rankFeature");
        mRankModel = options.GetString("rankModel");
        mFrameSliding = options.GetBool("annoFrameSliding",false);
        mNoSimTLV = options.GetBool("annoNoTimeLineVideo", false);
        mNoShotControl = options.GetBool("annoNoShotControl", false);
        mNoShotEditing = options.GetBool("annoNoShotEditing", false);
        mNoShotThreshold = options.GetBool("annoNoShotThreshold", false);
        mNoRankSlider = options.GetBool("annoNoRankSlider", false);
        mNoAnnoHistoryControl = options.GetBool("annoNoHistoryControl", false);
        mNoPrevNextControl = options.GetBool("annoNoPrevNextControl", false);
        mNoViewStripControl = options.GetBool("annoNoViewStripControl",false);
        //mWoggelOnLoadAnnotations = options.GetBool("annoWoggelOnLoadAnnotations",false);
    }

    void
    InitVars(SegmentationDocument* segDoc, String conceptSet, int annoPerVideo)
    {
        mSegDoc                 = segDoc;
        mConceptSet             = conceptSet;
        mMaxAnnoPerVideo        = annoPerVideo;

        mVidSet                 = mSegDoc->GetVideoSet();
        mKeyframes              = mSegDoc->GetKeyframes();
        mKeyframeSet            = mSegDoc->GetImSetKeyframes(false);

        if (!mKeyframeSet)
            mKeyframeSet        = mSegDoc->GetImSetKeyframes(true);

        mNrAnnoPerVideo         = 0;
        mNrAnnotated            = 0;
        mNrPositive             = 0;
        mNrSkip                 = 0;
        mNrNegative             = 0;
        mStepSize               = 1;

        mCurFile                = -1;
        mCurConcept             = -1;
        mCurMpeg7               = 0;
        mCurKey                 = 0;

        mRgbDataSrc             = 0;
        mShotSimSet             = 0;
        mSimSet                 = 0;
        mSimTLV                 = 0;

        mCurRankShot            = 0;
        mRankingMode            = true;
        mRankAll                = false;
        mRankFilterBits         = UNKNOWN_BIT;

        mShotThreshold          = 0.2f;
        mShotValueSB            = 0;
        mAnnoSearchRecursLevel  = 0;

        //mTitledPUNS             = 0;

        mRankVSB                = 0;
        mRankVSBAdjusting       = false;
        mAnnoHistoryVSBAdjusting = false;
        mPrevNextAnnoStayInVideo = true;
        mAnnoSearching          = false;
        mShowSegShots           = false;
        mShowThreshShots        = false;
        mCurMpeg7Changed        = false;
        mNoAutoNextAnno         = false;
    }


    void
    Init(SegmentationDocument* segDoc, String conceptSet, int maxAnnoPerVideo)
    {
        HandleCmdOptions();
        ReadKeyBindings();
        InitVars(segDoc,conceptSet,maxAnnoPerVideo);
        mNoAutoNextAnno = true;
        InitGUI();
        AllHandleNewCursor(segDoc->CursorToDir(0),false);
        mNoAutoNextAnno = false;
    }

    VideoAnnotations                mVideoAnnotations;
    std::vector<AnnoHistory>        mAnnoHistory;
    std::vector<int>                mShots;
    std::vector<int>                mCurShotFrames;
    std::vector<int>                mRankedShots;

    SegmentationDocument*           mSegDoc;
    Core::VideoSet::VideoSet*       mVidSet;
    Core::VideoSet::Keyframes*      mKeyframes;
    Core::ImageSet::ImageSet*       mKeyframeSet;
    Core::VideoSet::Mpeg7Doc*       mCurMpeg7;
    SimilarityTableSet*             mShotSimSet; // ShotBoundaries
    SimilarityTableSet*             mSimSet;     // Concept similarities+ranking
    RgbDataSrc*                     mRgbDataSrc;

    ImagesWindow*                   mImWnd;
    ImagesWindow*                   mImShotWnd;
    StaticText*                     mNrAnnoTxt;
    TextArea*                       mFrameText;
    TextArea*                       mShotText;
    CheckBox*                       mAllowSlidingChBox;
    CheckBox*                       mPNInVideoCB;
    CheckBox*                       mRankChBox;

    SimilarityTimeLineVideo*        mSimTLV;
    ValueScrollBar*                 mRankVSB;
    ValueScrollBar*                 mShotValueSB;
    ValueScrollBar*                 mAnnoHistoryVSB;
    UpDownNumber*                   mStepUpDown;
    UpDownNumber*                   mShotThresholdUDNr;
    UpDownButton*                   mPositiveUDBtn;
    UpDownButton*                   mNegativeUDBtn;
    UpDownButton*                   mSkippedUDBtn;
    UpDownButton*                   mUnknownUDBtn;

    Button*                         mNavModeBtn;
    Button*                         mRankAllBtn;
    Button*                         mRankNotAnnoBtn;
    Button*                         mShotLeftBtn;
    Button*                         mShotRightBtn;
    Button*                         mSyncBtn;

    String                          mRankSet;
    String                          mRankFeature;
    String                          mRankModel;
    String                          mConceptModel;
    String                          mConceptFeature;
    String                          mConceptSet;

    double                     mCurRelevance;
    float                      mShotThreshold;

    int                        mCurFile;
    int                        mCurConcept;
    int                        mCurKey;
    int                        mCurRankShot;
    int                        mMaxAnnoPerVideo;
    int                        mStepSize;
    int                        mNrAnnoPerVideo;
    int                        mNrAnnotated;
    int                        mNrPositive;
    int                        mNrSkip;
    int                        mNrNegative;
    int                        mAnnoSearchRecursLevel;
    int                        mRankFilterBits;
    int                        mAnnoHistoryPos;

    bool                       mRankAll;
    bool                       mShotValueSBAdjusting;
    bool                       mRankVSBAdjusting;
    bool                       mAnnoHistoryVSBAdjusting;

    bool                       mNoSimTLV;
    bool                       mNoShotControl;
    bool                       mNoShotEditing;
    bool                       mNoShotThreshold;
    bool                       mNoRankSlider;
    bool                       mNoAnnoHistoryControl;
    bool                       mNoPrevNextControl;
    bool                       mNoViewStripControl;
    //bool                       mWoggelOnLoadAnnotations;

    bool                       mRankingMode;
    bool                       mShowSegShots;
    bool                       mShowThreshShots;
    bool                       mPrevNextAnnoStayInVideo;
    bool                       mAnnoSearching;
    bool                       mNextAnnoFound;
    bool                       mCurMpeg7Changed;
    bool                       mFrameSliding;
    bool                       mNoAutoNextAnno;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(SegmentationDocumentGuiAnno, Visualization);

} // namespace Visualization
} // namespace Impala

#endif

---