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

---

AnnoPUNS.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890

#ifndef Impala_Visualization_AnnoPUNS_h
#define Impala_Visualization_AnnoPUNS_h

#include "Core/VideoSet/SegmentationDocument.h"
#include "Visualization/PunsOnlyControl.h"
#include "Visualization/ShowNextFromControl.h"
#include "Visualization/ImageSet.h"
#include "Visualization/ImageSetIdxGridScroller.h"
#include "OglGui/Button.h"
#include "OglGui/TextEdit.h"
#include "OglGui/CheckBox.h"

namespace Impala {
namespace Visualization {

class AnnoPUNS : public OglGui::Window,
                 public AppControlDoc,
                 public Core::Database::DataDocumentListener,
                 public PunsOnlyControlListener,
                 public ShowNextFromControlListener,
                 public OglGui::WindowListener,
                 public OglGui::ButtonListener,
                 public OglGui::CheckBoxListener,
                 public ImageSetIdxGridListener,
                 public ImagesListener
{
public:

    typedef std::vector<UCHAR>                       VideoAnnotation;
    typedef std::vector<VideoAnnotation*>            VideoAnnotations;
    typedef Core::VideoSet::SegmentationDocument     SegmentationDocument;
    typedef Core::VideoSet::Segmentation             Segmentation;
    typedef Core::VideoSet::Keyframes                Keyframes;
    typedef Core::ImageSet::ImageSet                 ImageSet;

    AnnoPUNS(OglGui::Window* parent, int w, int h, int imW, int imH,
             SegmentationDocument* segDoc, VideoAnnotations* vidAnnos,
             int controlId):
        OglGui::Window(parent, w, h),
        AppControlDoc(controlId, segDoc)
    {
        Init(w,h,imW,imH,segDoc,vidAnnos);
    }

    virtual void
    HandleNewFile()
    {
        if (mImageSetWnd)
        {
            mImageSetWnd->SetImageSelected(-1);
            mImageSetWnd->SetFirstVisY(0, true);
        }
        if (mImSetIdxGrid)
            mImSetIdxGrid->SetSelected(-1);

        int curFileId = mSegDoc->CurFileId();
        String vidName;
        if (curFileId != -1 && mVideoCheckBox->GetSelected())
            vidName = mSegDoc->GetDataSet()->GetFile(curFileId);
        mVideoText->SetText(vidName);

        UpdateAnno();
        UpdatePUNS();
    }

    void UpdateAnno()
    {
        mKeyframeVec.clear();

        Segmentation*   seg     = mSegDoc->GetSegmentation();
        Keyframes*      kFrames = mSegDoc->GetKeyframes();
        int             iSize   = mVideoAnnotations->size();
        int             bit     = -1;

        if (mPunsOnly->UnknownCheckBox()->GetSelected())
            bit = 0;
        if (mPunsOnly->PositiveCheckBox()->GetSelected())
            bit = 2;
        if (mPunsOnly->SkipCheckBox()->GetSelected())
            bit = 4;
        if (mPunsOnly->NegativeCheckBox()->GetSelected())
            bit = 8;

        for (int i=0; i<iSize; i++)
        {
            VideoAnnotation* vidAnno = (*mVideoAnnotations)[i];
            int  firstShot   = seg->GetFirstShotVideo(i);
            int  sz          = seg->GetNrShotsVideo(i);
            int  lastShot    = firstShot+sz;
            int  jSize       = vidAnno->size();
            if (mVideoCheckBox->GetSelected() && i != mSegDoc->CurFileId())
                continue;

            for (int j=0; j<jSize; j++)
            {
                int vidBit = (*vidAnno)[j];
                if (bit==-1 || vidBit == bit)
                {
                    int   kFrame   = kFrames->GetShotRKF(j+firstShot);
                    mKeyframeVec.push_back(kFrame);
                }
            }
        }
        int nrIm = mKeyframeVec.size();
        if (mImageSetWnd)
        {
            mShowNextFrom->MaxVal(nrIm);
            mStartIm = mShowNextFrom->StartVal();
        }
        if (mIdxGridTotalTxt)
            mIdxGridTotalTxt->SetText("Total: " + MakeString(nrIm));
    }

    void UpdatePUNS()
    {
        ImageSet*  imSet = mSegDoc->GetImSetKeyframes(true);
        if (mImageSetWnd)
        {
            mImageSetWnd->RemoveImages();
            mImageSetWnd->SetFirstVisY(0, true);
        }
        if (mImSetIdxGrid)
            mImSetIdxGrid->Clear();

        int curShot = mSegDoc->CurShot();
        int curKey = -1;
        if (curShot != -1)
            curKey = mKeyframes->GetShotRKF(curShot);
        int sz = mKeyframeVec.size();
        for (int i=0; i<mKeyframeVec.size(); i++)
        {
            if (i>=mStartIm && i<mStartIm+mNrToShow)
            {
                if (mImageSetWnd)
                    mImageSetWnd->AddImage(mKeyframeVec[i],imSet);
                if (mImSetIdxGrid)
                    mImSetIdxGrid->AddImageSetIdx(imSet,mKeyframeVec[i]);
                if (mKeyframeVec[i] == curKey)
                {
                    if (mImageSetWnd)
                        mImageSetWnd->SetImageSelected(i-mStartIm);
                    if (mImSetIdxGrid)
                        mImSetIdxGrid->SetSelected(i);
                }
            }
        }
        if (mImSetIdxGrid)
            mImSetIdxGrid->UpdateLayout(true);
    }

    virtual void PunsOnlyChanged(PunsOnlyControl *src, void* userData)
    {
        HandleNewFile();
    }

    virtual void
    ShowNextFromChanged(ShowNextFromControl *src, void* userData)
    {
        mNrToShow = src->NrToShow();
        HandleNewFile();
    }


    virtual void
    CheckBoxEvent(OglGui::CheckBox *src, bool checked, void* userData)
    {
        HandleNewFile();
    }

    virtual void
    ImageSelectionEvent(ImagesWindow* src, int imIndex, void* listenerData)
    {
        int keyfr = mKeyframeVec[imIndex+mStartIm];
        mSegDoc->GotoKeyfr(keyfr);
    }

    virtual void
    ImageSelectionEvent(ImageSetIdxGrid* src, int imIndex, void* listenerData)
    {
        int keyfr = mKeyframeVec[imIndex];
        mSegDoc->GotoKeyfr(keyfr);
    }
private:

    void Init(int w, int h, int imW, int imH, SegmentationDocument* segDoc,
              VideoAnnotations* vidAnnos)
    {
        CmdOptions& options = CmdOptions::GetInstance();
        mNrToShow = options.GetInt("annoNrToShow", 200);
        int punsNrToShow = options.GetInt("annoNrToShowPUNS", -1);
        if (punsNrToShow != -1)
            mNrToShow = punsNrToShow;

        mSegDoc = segDoc;
        mVideoAnnotations = vidAnnos;
        mKeyframeSet = mSegDoc->GetImSetKeyframes(false);
        mKeyframes   = mSegDoc->GetKeyframes();

        mVideoCheckBox = new OglGui::CheckBox(this, 100, 20, "OneVideo", false);
        mVideoCheckBox->SetCheckBoxListener(this, 0);
        mVideoText = new OglGui::TextArea(this, w/2 - 110, 20, "empty");
        mVideoText->SetBorderType(0);

        new OglGui::Strut(this,2000,1);
        mPunsOnly = new PunsOnlyControl(this, 446, 20, 15);
        mPunsOnly->SetListener(this);

        mIdxGridTotalTxt = 0;
        mStartIm = 0;
        mShowNextFrom = 0;
        mImageSetWnd = 0;
        mImSetIdxGrid = 0;
        if (!options.GetBool("annoPunsIdxGrid",false))
        {
            mShowNextFrom = new ShowNextFromControl(this, 350, 20, mNrToShow);
            mShowNextFrom->SetListener(this);
            mImageSetWnd = new Visualization::ImageSet(this,imW,imH,1.,7,5);
            mImageSetWnd->SetImagesListener(this, 0);
            mImageSetWnd->ConnectTo(this);
        }
        else
        {
            mIdxGridTotalTxt = new OglGui::StaticText(this, 160, 20, "Total:");
            mIdxGridTotalTxt->SetAlign(oglLeftAlign);
            mImSetIdxGridScroller =
                new ImageSetIdxGridScroller(this,2,2,w-4,h-60,7);
            mImSetIdxGrid = mImSetIdxGridScroller->ImSetIdxGrid();
            mImSetIdxGrid->SetImageSetIdxGridListener(this);
            mImSetIdxGrid->ShowDims(false);
            mImSetIdxGridScroller->ConnectTo(this);
            mNrToShow = 10000000;
        }

        AddDocListener(this);
    }

    VideoAnnotations*           mVideoAnnotations;
    std::vector<int>            mKeyframeVec;
    Core::ImageSet::ImageSet*   mKeyframeSet;
    Core::VideoSet::Keyframes*  mKeyframes;

    Visualization::ImageSet*    mImageSetWnd;
    ImageSetIdxGridScroller*    mImSetIdxGridScroller;
    ImageSetIdxGrid*            mImSetIdxGrid;
    OglGui::StaticText*         mIdxGridTotalTxt;
    SegmentationDocument*       mSegDoc;

    OglGui::TextArea*           mInfoText;
    OglGui::CheckBox*           mVideoCheckBox;
    PunsOnlyControl*            mPunsOnly;
    ShowNextFromControl*        mShowNextFrom;
    OglGui::TextArea*           mVideoText;

    int                         mStartIm;
    int                         mNrToShow;
};

} // namespace Visualization
} // namespace Impala

#endif

---