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

---

SimilarityTableSetRank.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef Impala_Visualization_SimilarityTableSetRank_h
#define Impala_Visualization_SimilarityTableSetRank_h

#include "Persistency/AnnotationTableRepository.h"
#include "Core/Table/Select.h"
#include "Core/Table/SelectQuids.h"
#include "Core/Table/Copy.h"
#include "Core/Table/AveragePrecision.h"
#include "Core/Table/RemoveRow.h"

#include "Core/ImageSet/IxsDocument.h"
#include "Core/VideoSet/SegmentationDocument.h"

#include "Core/VideoSet/PlayShot.h"
#include "OglGui/StringSelector.h"
#include "OglGui/StringListener.h"
#include "OglGui/TextArea.h"
#include "OglGui/CheckBox.h"


#include "OglGui/StaticText.h"
#include "OglGui/Button.h"
#include "OglGui/Strut.h"
#include "OglGui/TextEdit.h"

#include "Visualization/ImageSet.h"
#include "Visualization/ImageSetIdxGridScroller.h"
#include "Visualization/AppControlDoc.h"
#include "Visualization/Plot/Plot.h"
#include "Visualization/Plot/Line.h"
#include "Visualization/Plot/Points.h"
#include "Visualization/Plot/PlotNeedle.h"
#include "Visualization/PunsOnlyControl.h"
#include "Visualization/ShowNextFromControl.h"

namespace Impala {
namespace Visualization {

class SimilarityTableSetRank :  public Window,
                                public AppControlDoc,
                                public Core::Database::DataDocumentListener,
                                public Plot::PlottableMouseListener,
                                public ImageSetIdxGridListener,
                                public ImagesListener,
                                public PunsOnlyControlListener,
                                public ShowNextFromControlListener,
                                public OglGui::StringListener,
                                public OglGui::CheckBoxListener,
                                public OglGui::WindowListener,
                                public OglGui::ButtonListener
{

    static const int SET_POSITIVE = 100;
    static const int SET_NEGATIVE = 101;
    static const int SET_SKIP     = 102;
    static const int DELETE_CORR  = 103;
    static const int SAVE_CORR    = 104;

public:
    typedef Core::Table::QuidTable                  QuidTable;
    typedef Core::Table::SimilarityTableSet         SimilarityTableSet;
    typedef SimilarityTableSet::RankTableType       RankTableType;
    typedef SimilarityTableSet::SimTableType        SimTableType;
    typedef Core::Table::AnnotationTable            AnnotationTable;
    typedef Core::Database::DataDocument            DataDocument;
    typedef Core::VideoSet::SegmentationDocument    SegmentationDocument;
    typedef Core::ImageSet::IxsDocument             IxsDocument;

    SimilarityTableSetRank(OglGui::Window* parent, int wndWidth, int wndHeight,
                           int nrImOnRow, int thumbWidth, int thumbHeight,
                           double viewScale, SegmentationDocument* segDoc,
                           SimilarityTableSet* simSet, bool showPlotLine,
                           String annoSet, bool showPlotPoint, int controlId) :
        Window(parent, wndWidth, wndHeight, true),
        AppControlDoc(controlId, segDoc)
    {
        mIxsDoc = 0;
        mSegDoc = segDoc;
        mDataDoc = segDoc;
        Init(wndWidth, wndHeight, nrImOnRow, thumbWidth, thumbHeight, viewScale,
             simSet, showPlotLine, annoSet, showPlotPoint);
    }

    SimilarityTableSetRank(OglGui::Window* parent, int wndWidth, int wndHeight,
                           int nrImOnRow, int thumbWidth, int thumbHeight,
                           double viewScale, IxsDocument* ixsDoc,
                           SimilarityTableSet* simSet, bool showPlotLine,
                           String annoSet, bool showPlotPoint, int controlId) :
        Window(parent, wndWidth, wndHeight, true),
        AppControlDoc(controlId, ixsDoc)
    {
        mSegDoc = 0;
        mIxsDoc = ixsDoc;
        mDataDoc = ixsDoc;

        Init(wndWidth, wndHeight, nrImOnRow, thumbWidth, thumbHeight, viewScale,
             simSet, showPlotLine, annoSet, showPlotPoint);
    }

    void Init(int wndWidth, int wndHeight, int nrImOnRow, int thumbWidth,
         int thumbHeight, double viewScale, SimilarityTableSet* simSet,
         bool showPlotLine, String annoSet, bool showPlotPoint)
    {
        CmdOptions& options = CmdOptions::GetInstance();

        mSimSet = simSet;
        mAnnoSet = annoSet;
        mCorrectionSet = options.GetString("conceptCorrections");
        mImagesSet = 0;
        mImSetIdxGrid = 0;
        mIdxGridTotalTxt = 0;;

        mShowNextFrom = 0;
        mCurConcept = -1;
        mAnno = 0;
        mAnnoConcept = -2;
        mCorrections = 0;
        mQualifiedRanking = new AnnotationTable();
        mSelectedRanking = new AnnotationTable();
        mStartIm = 0;
        mLineSize1 = -1;
        mLineData1 = 0;
        mLineSize2 = -1;
        mLineData2 = 0;
        mPoints = 0;
        mFloatWnd = 0;
        mViewWidth = thumbWidth * viewScale + 0.5;

        mOptionBits = -1;
        mCurFileId = -1;
        mImageSelected = -1;

        mNrToShow = options.GetInt("annoNrToShow", 200);
        int truthNrToShow = options.GetInt("annoNrToShowConceptsTruth",-1);
        int simNrToShow = options.GetInt("annoNrToShowConceptsSim",-1);
        int conNrToShow = options.GetInt("annoNrToShowConcepts",-1);
        if (showPlotPoint && truthNrToShow!=-1)
            mNrToShow = truthNrToShow;
        else if (showPlotLine && simNrToShow!=-1)
            mNrToShow = simNrToShow;
        else if (conNrToShow != -1)
            mNrToShow = conNrToShow;

        mKeyframes = mSegDoc ? mSegDoc->GetKeyframes() : 0;
        mKeyframeSet =
            mSegDoc ? mSegDoc->GetImSetKeyframes(true) : mIxsDoc->GetImageSet();
        AddDocListener(this);

        mStringSelector = new OglGui::StringSelector(this, wndWidth, 60);
        mStringSelector->SetStringListener(this, 0);
        int heightUsed = 60;

        mPlotLine1 = 0;
        mPlotLine2 = 0;
        if (showPlotLine)
        {
            mPlotLine1 = new Plot::Plot(this, wndWidth, 180);
            heightUsed += 180;
            mLine1 = new Visualization::Plot::Line(0);
            mPlotLine1->Add(mLine1);
            mPlotLine1->AutoScale();
            mPlotLine1->SetDrawAxes(true);

            mPlotLine2 = new Visualization::Plot::Plot(this, wndWidth, 180);
            heightUsed += 180;
            mLine2 = new Visualization::Plot::Line(0);
            mLine2->SetPlottableMouseListener(this,mPlotLine2);
            mPlotLine2->Add(mLine2);
            mPlotLine2->AutoScale();
            mPlotLine2->SetDrawAxes(true);
            mNeedle2 = new Plot::PlotNeedle(0,1500,0,1,0);
            //mNeedle2->SetRoundOffset(0.6);
            mNeedle2->SetColor(1,(165./255),0);
            mPlotLine2->Add(mNeedle2);
        }

        mPlotPoints = 0;
        if (showPlotPoint)
        {
            int h = mSegDoc ? 430 : 215;
            mPlotPoints = new Plot::Plot(this, wndWidth, h);
            heightUsed += h;
            mPoints = new Plot::Points();
            mPoints->SetPlottableMouseListener(this,mPlotPoints);
            mPoints->HighLightColor(0xffffa500);
            mPlotPoints->Add(mPoints);
            //mPlotPoints->AutoScale();
            mPlotPoints->SetDrawAxes(true);
        }

        String info = (mSimSet) ? mSimSet->GetDescription() : "no sims";
        mInfoText = new OglGui::TextArea(this, wndWidth/2 - 5, 20, info);
        mInfoText->SetBorderType(0);
        mVideoCheckBox = new OglGui::CheckBox(this, 100, 20, "OneVideo", false);
        mVideoCheckBox->SetCheckBoxListener(this, 0);

        mVideoText = new OglGui::TextArea(this, wndWidth/2 - 110, 20, "empty");
        mVideoText->SetBorderType(0);
        heightUsed += 20;

        mRkfCheckBox = new OglGui::CheckBox(this, 110, 20, "Only RKF", false);
        mRkfCheckBox->SetCheckBoxListener(this, 0);
        if (!mSegDoc)
        {
            mVideoCheckBox->SetVisible(false);
            mVideoText->SetVisible(false);
            mRkfCheckBox->SetVisible(false);
        }

        mPunsOnly = new PunsOnlyControl(this, 334, 20, 13);
        mPunsOnly->SetListener(this);

        if (!mCorrectionSet.empty())
        {
            OglGui::Button* but;
            but = new OglGui::Button(this, 120, 22, "SetPositive");
            but->SetButtonListener(this, SET_POSITIVE);
            but = new OglGui::Button(this, 120, 22, "SetNegative");
            but->SetButtonListener(this, SET_NEGATIVE);
            but = new OglGui::Button(this, 120, 22, "SetSkip");
            but->SetButtonListener(this, SET_SKIP);
            but = new OglGui::Button(this, 120, 22, "DeleteCorrection");
            but->SetButtonListener(this, DELETE_CORR);
            but = new OglGui::Button(this, 120, 22, "SaveCorrections");
            but->SetButtonListener(this, SAVE_CORR);
        }

        heightUsed += 30;

        if (!options.GetBool("conceptIdxGrid",true))
        {
            mShowNextFrom = new ShowNextFromControl(this, 350, 20, mNrToShow);
            mShowNextFrom->SetListener(this);
            new OglGui::Strut(this,200,1);

            int nrRow = (wndHeight - heightUsed) / (thumbHeight + 6);
            mImagesSet = new ImageSet(this, thumbWidth, thumbHeight, viewScale,
                                      nrImOnRow, nrRow);
            mImagesSet->ActivateInfoBox(false);
            mImagesSet->SetImagesListener(this, 0);
        }
        else
        {
            mIdxGridTotalTxt = new OglGui::StaticText(this, 160, 20, "Total:");
            mIdxGridTotalTxt->SetAlign(oglLeftAlign);
            mImSetIdxGridScroller =
                new ImageSetIdxGridScroller(this,2,2,wndWidth-4,
                                            wndHeight-heightUsed-14,nrImOnRow);
            mNrToShow = 1000000;
            mImSetIdxGrid = mImSetIdxGridScroller->ImSetIdxGrid();
            mImSetIdxGrid->SetImageSetIdxGridListener(this);
            //mImSetIdxGrid->ShowNames(false);
            mImSetIdxGrid->ShowDims(false);
            oglSys.SetSelectColor(mImSetIdxGrid->GetOGLWND(),0xffffa500);
        }

        if (mPlotPoints || mPlotLine2)
        {
            mFloatWnd = new ImagesWindow(this,0,0,200,200);
            mFloatWnd->SetViewSize(200,200);
        }

        std::vector<String> names;
        if (mSimSet)
            names = mSimSet->GetNames();
        for (int i=0 ; i<names.size() ; i++)
        {
            mStringSelector->AddString(names[i]);
            mDataDoc->AddConcept(names[i]);
        }
        mDataDoc->SetConcept(0);
    }

    void CheckCurrentActual()
    {
        mCurConcept = mDataDoc->GetConceptIdx();
        if (mCurConcept != mStringSelector->GetCurrentStringIdx())
            mStringSelector->SetCurrentString(mCurConcept, true);
        mCurFileId = mDataDoc->CurFileId();
        String vidName;
        if (mCurFileId != -1)
            vidName = mDataDoc->GetDataSet()->GetFile(mCurFileId);
        mVideoText->SetText(vidName);
    }

    void ClearImages()
    {
        mImageSelected = -1;
        if (mImagesSet)
        {
            mImagesSet->RemoveImages();
            mImagesSet->SetFirstVisY(0, true);
            mImagesSet->SetImageSelected(-1);
        }
        if (mImSetIdxGrid)
            mImSetIdxGrid->Clear();
    }

    void HandleUpdate(bool doUpdateAnno)
    {
Timer timer(1);
ILOG_INFO("============================= start");
ILOG_INFO("1 : " << timer.SplitTime() << " = " << timer.SplitTimeStr());
        if (doUpdateAnno)
            UpdateAnno();
ILOG_INFO("2 : " << timer.SplitTime() << " = " << timer.SplitTimeStr());
        UpdateRanking();
ILOG_INFO("3 : " << timer.SplitTime() << " = " << timer.SplitTimeStr());
        int nrPlot = mSelectedRanking->Size();
        int nrIm = Min(nrPlot, mNrToShow);
        int nrOk = 0;
        UpdateLineSize(Min(nrPlot, 1000));
        SimTableType* simTable = mSimSet->GetSimTable(mCurConcept);
        for (int i=0 ; i<nrPlot ; i++)
        {
            Quid quid = mSelectedRanking->Get1(i);
            if (i>=mStartIm && i<mStartIm+mNrToShow)
            {
                int imSetId = FindImSetId(quid);
                if (imSetId == -1)
                {
                    ILOG_ERROR("Unable to find keyframe for " << QuidObj(quid));
                }
                else
                {
                    if (mImagesSet)
                        mImagesSet->AddImage(imSetId, mKeyframeSet);
                    if (mImSetIdxGrid)
                        mImSetIdxGrid->AddImageSetIdx(mKeyframeSet,imSetId);
                }
            }
            if (mPlotLine1 && i < mLineSize2)
            {
                int idx = mSimSet->FindQuid(quid);
                if ((idx >= 0) && (idx < mSimSet->TableSize()))
                    mLineData2[i] = simTable->Get1(idx);
                else
                    mLineData2[i] = 0;
                if (i<mLineSize1)
                    mLineData1[i] = mLineData2[i];
            }
            if (mPlotPoints && mAnno)
            {
                int x = i%200;
                int y = -(i/200);
                if (mSelectedRanking->IsPositive(i))
                {
                    mPoints->AddPoint(x, y, 0, 0, 1, 0, 3, false);
                    nrOk++;
                }
                else if (mSelectedRanking->IsNegative(i))
                    mPoints->AddPoint(x, y, 0, 1, 0, 0, 3, false);
                else if (mSelectedRanking->IsSkip(i))
                    mPoints->AddPoint(x, y, 0, 1, 1, 0, 3, false);
                else
                    mPoints->AddPoint(x, y, 0, 0.5, 0.5, 0.5, 3, false);
            }
        }
        if (mImSetIdxGrid)
            mImSetIdxGrid->UpdateLayout(true);

ILOG_INFO("4 : " << timer.SplitTime() << " = " << timer.SplitTimeStr());
        UpdateLinePlot();
ILOG_INFO("5 : " << timer.SplitTime() << " = " << timer.SplitTimeStr());
        UpdatePointPlot();
        ILOG_INFO("Skipping judgement for efficiency reasons");
        /*
ILOG_INFO("6 : " << timer.SplitTime() << " = " << timer.SplitTimeStr());
        if (mPlotPoints)
        {
            String judge(" ");
            if (mAnno)
            {
                using Core::Table::AveragePrecisionJudged;
                Real64 ap = AveragePrecisionJudged(mSelectedRanking, mAnno,
                                                   false, -1, true);
                judge = " : nrOK = " + MakeString(nrOk) + " (in first " +
                    MakeString(nrPlot) + "), nrMissed = " +
                    MakeString(mAnno->GetNrPositive() - nrOk) +
                    ", ap = " + MakeString(ap);
            }
            mInfoText->SetText(mSimSet->GetDescription() + judge);
        }
        */
ILOG_INFO("D : " << timer.SplitTime() << " = " << timer.SplitTimeStr());
        SetCurrent(mStartIm);
    }

    virtual void
    HandleNewFile()
    {
        CheckCurrentActual();
        if (mAnnoConcept == mCurConcept && mOptionBits == OptionBits() &&
            !((mOptionBits&1) && mCurFileId != mDataDoc->CurFileId()))
        {
            HandleImageSelection(mImageSelected);
            return;
        }
        mOptionBits = OptionBits();
        ClearImages();
        if (mPlotPoints) 
            mPoints->Clear();
        if ((mSegDoc && !mKeyframes) || !(mKeyframeSet && mSimSet))
            return;
        HandleUpdate(true);
        if (!mPlotPoints)
            HandleImageSelection(mImageSelected);
    }

    int ShowImageInfo(int rankIdx)
    {
        Quid quid = mSelectedRanking->Get1(rankIdx);
        int imSetId = FindImSetId(quid);
        SimTableType* simTable = mSimSet->GetSimTable(mCurConcept);
        String truth;
        if (mAnno)
        {
            truth = " " + mAnno->GetQualificationString(quid) + " ";
        }
        if (mCorrections)
        {
            truth += "corr: " + mCorrections->GetQualificationString(quid) + " ";
        }
        int idx = mSimSet->FindQuid(quid);
        mInfoText->SetText("rank = " + MakeString(rankIdx) +
                           ", sim = " + MakeString(simTable->Get1(idx))
                           + " " + truth + mSimSet->GetDescription());
        return imSetId;
    }

    void ShowFloatWnd(Plot::Plot* plot, int idx, double x, double y)
    {
        if (!mFloatWnd)
            return;
        ShowImageInfo(idx);
        if (mFloatIdx != idx)
        {
            mFloatWnd->RemoveImages();
            Quid quid = mSelectedRanking->Get1(idx);
            int imSetId = FindImSetId(quid);
            mFloatWnd->AddImage(imSetId,mKeyframeSet);
            mFloatIdx = idx;
        }
        double wX, wY;
        plot->Window2Pixel(x,y,wX,wY);
        mFloatWnd->SetDimensions(plot->X()+wX+8,
                                 plot->Y()+wY-200,RETAIN,RETAIN);
        mFloatWnd->SetVisible(true);
    }

    void MakePointVisible(int idx)
    {
        if (!mPlotPoints || idx < 0 || idx >= mPoints->Size())
            return;

        double px = mPoints->PointX(idx);
        double py = mPoints->PointY(idx);
        if (mPlotPoints->IsVisible(px,py))
            return;
        double wX, wY;
        mPlotPoints->Window2Pixel(px,py,wX,wY);
        if (wX < 0)
            wX = 20;
        if (wX > mPlotPoints->W())
            wX = mPlotPoints->W()-20;
        if (wY < 0)
            wY = 20;
        if (wY > mPlotPoints->H())
            wY = mPlotPoints->H()-20;
        mPlotPoints->MakeVisibleAtPix(px,py,wX,wY);
    }

    void HandleImageSelection(int rankIdx)
    {
        if (rankIdx < 0)
            return;
        int keyfr = ShowImageInfo(rankIdx);
        if (mSegDoc)
            mSegDoc->GotoKeyfr(keyfr);
        if (mIxsDoc)
            mIxsDoc->CursorToFile(keyfr);
        SetCurrent(rankIdx);
    }

    void HandlePlotIdxSelected(int idx)
    {
        if (idx < 0 || idx >= mSelectedRanking->Size())
            return;
        if (mImagesSet)
        {
            if (idx < mStartIm || idx >= mStartIm + mNrToShow)
                mShowNextFrom->StartVal(idx);
            int nrCol = mImagesSet->W() / (mViewWidth+3);
            mImagesSet->SetFirstVisY((idx - mStartIm)/nrCol, true);
        }
        if (mImSetIdxGrid)
            mImSetIdxGrid->SetFirstVisRow(idx);
        HandleImageSelection(idx);
    }

    virtual void
    StringSelectionEvent(OglGui::StringSelector* src, int strIndex,
                         void* listenerData)
    {
        mDataDoc->SetConcept(strIndex);
        if (mShowNextFrom)
            mShowNextFrom->StartVal(0);
        else
            HandleNewFile();
    }

    virtual void PunsOnlyChanged(PunsOnlyControl *src, void* userData)
    {
        if (mShowNextFrom)
            mShowNextFrom->StartVal(0);
        else
            HandleNewFile();
    }

    virtual void
    ShowNextFromChanged(ShowNextFromControl *src, void* userData)
    {
        mOptionBits = -1;
        HandleNewFile();
    }

    virtual void
    CheckBoxEvent(OglGui::CheckBox *src, bool checked, void* userData)
    {
        if (mShowNextFrom)
            mShowNextFrom->StartVal(0);
        else
            HandleNewFile();
    }

    virtual void
    ButtonSelectionEvent(OglGui::Button* src, void* vData)
    {
        int listenerData = (long long) vData;
        HandleCorrection(listenerData);
    }

    virtual void
    ImageSelectionEvent(ImagesWindow* src, int imIndex, void* listenerData)
    {
        HandleImageSelection(imIndex+mStartIm);
    }

    virtual void
    ImageSelectionEvent(ImageSetIdxGrid* src, int imIndex, void* listenerData)
    {
        HandleImageSelection(imIndex);
    }

    virtual void
    HandleNewKey(int c, int state)
    {
        ILOG_DEBUG("HandleNewKey: " << c);
        if (c == 'P' && mSegDoc)
        {
            if (mSegDoc->HasCurShot())
                Core::VideoSet::PlayShot(mSegDoc->GetSegmentation(),
                                         mSegDoc->CurShot());
        }
        if (c == '1')
            HandleCorrection(SET_POSITIVE);
        if (c == '2')
            HandleCorrection(SET_NEGATIVE);
        if (c == '3')
            HandleCorrection(SET_SKIP);
        if (c == '4')
            HandleCorrection(DELETE_CORR);
        if (c == '5')
            HandleCorrection(SAVE_CORR);
    }

    virtual void
    OnMouse(Plot::Plottable *src, double x, double y, int msg, int but,
            int state, void *userData)
    {
        if (mFloatWnd)
            mFloatWnd->SetVisible(false);

        if (state & (oglShift | oglControl))
            return;

        Plot::Plot* plot=0;
        int         idx;
        bool        validIdx = false;

        if (mPlotPoints && (mPlotPoints == (Plot::Plot*)userData))
        {
            plot = mPlotPoints;
            idx = ((int)(x+.5)) % 200 - 200 * ((int)(y-0.5));
            validIdx = x>=-0.5 && x <= 200.5 &&
                       idx >= 0 && idx < mSelectedRanking->Size();
        }
        if (mPlotLine2 && (mPlotLine2 == (Plot::Plot*)userData))
        {
            plot = mPlotLine2;
            idx = x;
            validIdx = idx >= 0 && idx < mSelectedRanking->Size();
        }
        if (msg == oglMouseUp)
        {
            if (but==oglLeftButton && !(state&oglRightButton) && validIdx)
                HandlePlotIdxSelected(idx);
            else
                HandleImageSelection(mImageSelected);
        }
        else if (validIdx && (state & (oglRightButton | oglLeftButton)))
            ShowFloatWnd(plot,idx,x,y);
        if (validIdx && (state & oglAlt))
            HandlePlotIdxSelected(idx);
    }

private:

    int
    FindImSetId(Quid quid)
    {
        if (mSegDoc && QuidClass(quid) == QUID_CLASS_FRAME) // assume it is a keyframe
        {
            return mKeyframes->GetFrameId(quid);
        }
        if (mSegDoc && QuidClass(quid) == QUID_CLASS_SHOT)
        {
            int shotId = mSegDoc->GetSegmentation()->GetShotId(quid);
            return mKeyframes->GetShotRKF(shotId);
        }
        if (mIxsDoc && QuidClass(quid) == QUID_CLASS_IMAGE)
        {
            Core::ImageSet::ImageSet* imSet = mIxsDoc->GetImageSet();
            return (int) (imSet ? (quid & QUID_ID_MASK) : -1);
        }

        return -1;
    }

    void
    HandleCorrection(int code)
    {
        if (mCorrections == 0)
        {
            ILOG_ERROR("No corrections");
            return;
        }
        if (code == SAVE_CORR)
        {
            SaveCorrections();
            return;
        }
        if (mImageSelected == -1)
        {
            ILOG_ERROR("No image selected");
            return;
        }
        Quid quid = mSelectedRanking->Get1(mImageSelected);
        int cIndex = mCorrections->GetIndex(quid);
        int rIndex = mQualifiedRanking->GetIndex(quid);
        if (rIndex == mQualifiedRanking->Size())
        {
            ILOG_ERROR("HandleCorrection: Logic error");
        }
        if (code == DELETE_CORR)
        {
            if (cIndex == mCorrections->Size())
            {
                ILOG_ERROR("HandleCorrection: cannot find correction");
            }
            else
            {
                Core::Table::RemoveRow(mCorrections, cIndex);
                mQualifiedRanking->Set2(rIndex, mAnno->GetQualification(quid));
            }
        }
        else if (cIndex == mCorrections->Size())
        {
            if (code == SET_POSITIVE)
            {
                mCorrections->AddPositive(quid);
                mQualifiedRanking->SetPositive(rIndex);
            }
            else if (code == SET_NEGATIVE)
            {
                mCorrections->AddNegative(quid);
                mQualifiedRanking->SetNegative(rIndex);
            }
            else
            {
                mCorrections->AddSkip(quid);
                mQualifiedRanking->SetSkip(rIndex);
            }
        }
        else
        {
            if (code == SET_POSITIVE)
            {
                mCorrections->SetPositive(cIndex);
                mQualifiedRanking->SetPositive(rIndex);
            }
            else if (code == SET_NEGATIVE)
            {
                mCorrections->SetNegative(cIndex);
                mQualifiedRanking->SetNegative(rIndex);
            }
            else
            {
                mCorrections->SetSkip(cIndex);
                mQualifiedRanking->SetSkip(rIndex);
            }
        }
        // "Minimal" HandleNewFile
        int curImage = mImageSelected;
        ClearImages();
        if (mPlotPoints)
            mPoints->Clear();
        HandleUpdate(false);
        HandlePlotIdxSelected(curImage);
    }

    void
    SaveCorrections()
    {
        Core::Database::RawDataSet* dataSet = mDataDoc->GetDataSet();
        int qClass = mSimSet->GetQuidClass();
        typedef Persistency::AnnotationTableLocator Loc;
        String concept = mCorrections->GetLabel();
        Loc cLoc(dataSet->GetLocator(), qClass, mCorrectionSet, concept);
        ILOG_INFO("Saving corrections for " << concept);
        Persistency::AnnotationTableRepository().Replace(cLoc, mCorrections);
    }

    void
    UpdateAnno()
    {
        if (mAnnoSet.empty())
        {
            Core::Table::Copy(mQualifiedRanking,
                              mSimSet->GetRankTable(mCurConcept));
            return;
        }
        if (mAnnoConcept == mCurConcept)
            return;

        if (mAnno)
        {
            delete mAnno;
            mAnno = 0;
        }
        if (mCorrections)
        {
            SaveCorrections();
            delete mCorrections;
            mCorrections = 0;
        }

        Core::Database::RawDataSet* dataSet = mDataDoc->GetDataSet();
        int qClass = mSimSet->GetQuidClass();
        typedef Persistency::AnnotationTableLocator Loc;
        String concept = mDataDoc->GetConcept();
        Loc aLoc(dataSet->GetLocator(), qClass, mAnnoSet, concept);
        if (! Persistency::AnnotationTableRepository().Exists(aLoc))
        {
            ILOG_ERROR("No annations for " << concept);
            mAnnoConcept = -2;
            Core::Table::Copy(mQualifiedRanking,
                              mSimSet->GetRankTable(mCurConcept));
            return;
        }
        mAnno = Persistency::AnnotationTableRepository().Get(aLoc);

        if (!mCorrectionSet.empty())
        {
            aLoc.SetConceptSet(mCorrectionSet);
            if (Persistency::AnnotationTableRepository().Exists(aLoc))
            {
                ILOG_INFO("Loading corrections for " << concept);
                mCorrections = Persistency::AnnotationTableRepository().Get(aLoc);
            }
            else
            {
                ILOG_INFO("No existing corrections for " << concept);
                mCorrections = new AnnotationTable(concept, 0);
            }
        }

        mAnnoConcept = mCurConcept;
        Core::Table::Copy(mQualifiedRanking, mSimSet->GetRankTable(mCurConcept));
        for (int i=0 ; i<mQualifiedRanking->Size() ; i++)
        {
            Quid quid = mQualifiedRanking->Get1(i);
            mQualifiedRanking->Set2(i, mAnno->GetQualification(quid));
            if (mCorrections)
            {
                int index = mCorrections->GetIndex(quid);
                if (index != mCorrections->Size())
                    mQualifiedRanking->Set2(i, mCorrections->Get2(index));
            }
        }
    }

    int OptionBits()
    {
        int bits = 0;
        if (mVideoCheckBox->GetSelected())
            bits |= 1;
        if (mPunsOnly->PositiveCheckBox()->GetSelected())
            bits |= 2;
        if (mPunsOnly->NegativeCheckBox()->GetSelected())
            bits |= 4;
        if (mPunsOnly->SkipCheckBox()->GetSelected())
            bits |= 8;
        if (mRkfCheckBox->GetSelected())
            bits |= 16;
        return bits;
    }

    void
    UpdateRanking()
    {
        using Core::Table::CriterionQuidObjectEquals;
        using Core::Table::CriterionElement2Equals;
        Core::Table::Copy(mSelectedRanking, mQualifiedRanking);
        if (mSegDoc && mVideoCheckBox->GetSelected())
        {
            CriterionQuidObjectEquals<AnnotationTable> crit(mDataDoc->CurFileId());
            Core::Table::Select(mSelectedRanking, mSelectedRanking, crit, true);
        }
        if (mPunsOnly->PositiveCheckBox()->GetSelected())
        {
            CriterionElement2Equals<AnnotationTable> crit(1.0);
            Core::Table::Select(mSelectedRanking, mSelectedRanking, crit, true);
        }
        if (mPunsOnly->NegativeCheckBox()->GetSelected())
        {
            CriterionElement2Equals<AnnotationTable> crit(-1.0);
            Core::Table::Select(mSelectedRanking, mSelectedRanking, crit, true);
        }
        if (mPunsOnly->SkipCheckBox()->GetSelected())
        {
            CriterionElement2Equals<AnnotationTable> crit(0.0);
            Core::Table::Select(mSelectedRanking, mSelectedRanking, crit, true);
        }
        if (mSegDoc && mRkfCheckBox->GetSelected())
        {
            bool* filter = new bool[mSelectedRanking->Size()];
            for (int i=0 ; i<mSelectedRanking->Size() ; i++)
            {
                Quid q = mSelectedRanking->Get1(i);
                int keyId = mKeyframes->GetFrameId(q);
                filter[i] = mKeyframes->IsRKF(keyId);
            }
            Core::Table::Select(mSelectedRanking, mSelectedRanking, filter, true);
            delete filter;
        }
        int nrIm = mSelectedRanking->Size();
        if (mImagesSet)
        {
            mShowNextFrom->MaxVal(nrIm);
            mStartIm = mShowNextFrom->StartVal();
            mNrToShow = mShowNextFrom->NrToShow();
        }
        if (mIdxGridTotalTxt)
            mIdxGridTotalTxt->SetText("Total: " + MakeString(nrIm));
    }

    void
    UpdateLineSize(int nrCandidates)
    {
        if (!mPlotLine1)
            return;
        mLineSize1 = Min(50, nrCandidates);
        mLineSize2 = Min(1000, nrCandidates);
        if (mLineData1)
            delete mLineData1;
        if (mLineData2)
            delete mLineData2;
        mLineData1 = new double[mLineSize1];
        mLineData2 = new double[mLineSize2];
    }

    void
    UpdateLinePlot()
    {
        if (!mPlotLine1)
            return;

        mLine1->SetData(mLineData1, mLineSize1);
        mLine1->SetDomain(0, mLineSize1);
        if (mLineSize1 > 1)
            mPlotLine1->AutoScale();

        mLine2->SetData(mLineData2, mLineSize2);
        mLine2->SetDomain(0, mLineSize2);
        mLine2->UpdateDimensionsY();
        double minY, maxY;
        mLine2->GetDimensionsY(minY,maxY);
        mNeedle2->SetDimensionsY(minY,maxY);
        if (mLineSize2 > 1)
            mPlotLine2->AutoScale();
    }

    void
    UpdatePointPlot()
    {
        if (!mPlotPoints)
            return;

        mPoints->UpdateDimensions();
        mPlotPoints->SetCenter(100, mSegDoc ? -40 : -12.5, 0);
        mPlotPoints->SetRange(200, mSegDoc ? 80 : 25, 0);
    }

    void SetCurrent(int idx)
    {
        mImageSelected = idx;
        if (mImagesSet)
            mImagesSet->SetImageSelected(mImageSelected-mStartIm);
        if (mImSetIdxGrid)
            mImSetIdxGrid->SetSelected(mImageSelected);
        if (mPlotPoints)
        {
            mPoints->HighLightPoint(idx);
            MakePointVisible(idx);
        }
        if (mPlotLine2)
            mNeedle2->MoveTo(idx);
    }

    DataDocument*                mDataDoc;
    SegmentationDocument*        mSegDoc;
    IxsDocument*                 mIxsDoc;

    SimilarityTableSet*          mSimSet;
    String                       mAnnoSet;
    String                       mCorrectionSet;
    int                          mCurConcept;
    AnnotationTable*             mAnno;     // "ground truth" (possibly partial)
    int                          mAnnoConcept;      // current concept in mAnno
    AnnotationTable*             mCorrections; // user modification of mAnno
    AnnotationTable*             mQualifiedRanking; // full ranking, qualifiers
                                                    // only valid if(mAnno)
    AnnotationTable*             mSelectedRanking;  // user selection
    Core::VideoSet::Keyframes*   mKeyframes;
    Core::ImageSet::ImageSet*    mKeyframeSet;

    int                          mLineSize1;
    int                          mLineSize2;
    double*                      mLineData1;
    double*                      mLineData2;
    Visualization::Plot::Line*   mLine1;
    Visualization::Plot::Line*   mLine2;
    Plot::PlotNeedle*            mNeedle2;

    Visualization::Plot::Plot*   mPlotLine1;
    Visualization::Plot::Plot*   mPlotLine2;
    Plot::Points*                mPoints;
    Plot::Plot*                  mPlotPoints;

    ImagesWindow*                mFloatWnd;
    int                          mFloatIdx;

    OglGui::StringSelector*      mStringSelector;
    OglGui::TextArea*            mInfoText;
    OglGui::CheckBox*            mVideoCheckBox;
    OglGui::CheckBox*            mRkfCheckBox;
    OglGui::TextArea*            mVideoText;

    PunsOnlyControl*             mPunsOnly;
    ShowNextFromControl*         mShowNextFrom;

    ImageSetIdxGridScroller*     mImSetIdxGridScroller;
    ImageSetIdxGrid*             mImSetIdxGrid;
    OglGui::StaticText*          mIdxGridTotalTxt;

    ImageSet*                    mImagesSet;
    int                          mImageSelected;
    int                          mStartIm;
    int                          mNrToShow;
    int                          mViewWidth;

    int                          mOptionBits;
    int                          mCurFileId;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(SimilarityTableSetRank, Visualization);


} // namespace Visualization
} // namespace Impala

#endif

---