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

---

AnnotationTableGui.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef Impala_Visualization_AnnotationTableGui_h
#define Impala_Visualization_AnnotationTableGui_h

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

#include "OglGui/StringSelector.h"
#include "OglGui/StringListener.h"
#include "Visualization/ImageSet.h"
#include "Visualization/ImageSetIdxGridScroller.h"
#include "Visualization/AppControlDoc.h"

namespace Impala {
namespace Visualization {

class AnnotationTableGui :
        public Window,
        public AppControlDoc,
        public Core::Database::DataDocumentListener,
        public ImageSetIdxGridListener,
        public ImagesListener,
        public OglGui::StringListener
{
public:
    typedef Core::Table::AnnotationTable            AnnotationTable;
    typedef Core::Database::DataDocument            DataDocument;
    typedef Core::VideoSet::SegmentationDocument    SegmentationDocument;
    typedef Core::ImageSet::IxsDocument             IxsDocument;

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

    AnnotationTableGui(OglGui::Window* parent, int wndWidth, int wndHeight,
                       int nrImOnRow, int thumbWidth, int thumbHeight,
                       double viewScale, IxsDocument* ixsDoc,
                       String annoSet, int controlId) :
        Window(parent, wndWidth, wndHeight, true),
        AppControlDoc(controlId, ixsDoc)
    {
        mSegDoc = 0;
        mIxsDoc = ixsDoc;
        mDataDoc = ixsDoc;
        Init(wndWidth, wndHeight, nrImOnRow, thumbWidth, thumbHeight,
             viewScale, annoSet);
    }

    void Init(int wndWidth, int wndHeight, int nrImOnRow, int thumbWidth,
              int thumbHeight, double viewScale, String annoSet)
    {
        mAnnoSet = annoSet;
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String fName;
        if (mSegDoc)
            fName = mSegDoc->GetVideoSet()->GetFilePathAnnotation(annoSet,
                                                                  false, false);
        if (mIxsDoc)
            fName = mIxsDoc->GetImageSet()->GetFilePathAnnotation(annoSet,
                                                                  false, false);
        mDataDoc->LoadConcepts(fName);
#else // REPOSITORY_USED
        mSegDoc->LoadConcepts(annoSet);
#endif // REPOSITORY_USED
        mCurConcept = -1;
        mAnno = 0;
        mImagesSet = 0;
        mImSetIdxGrid = 0;

        AddDocListener(this);

        mStringSelector = new OglGui::StringSelector(this, wndWidth, 120);
        mStringSelector->SetStringListener(this, 0);
        for (int i=0 ; i<mDataDoc->NrConcepts() ; i++)
            mStringSelector->AddString(mDataDoc->GetConcept(i));
        int heightUsed = 120;

        CmdOptions& options = CmdOptions::GetInstance();
        if (!options.GetBool("annoTableIdxGrid",true))
        {
            int nrRow = (wndHeight - heightUsed) / (thumbHeight + 6);
            mImagesSet = new ImageSet(this, thumbWidth, thumbHeight, viewScale,
                                      nrImOnRow, nrRow);
            mImagesSet->ActivateInfoBox(false);
            mImagesSet->SetImagesListener(this, 0);
        }
        else
        {
            mImSetIdxGridScroller =
                new ImageSetIdxGridScroller(this,2,2,wndWidth-4,
                                            wndHeight-heightUsed-12,nrImOnRow);
            mImSetIdxGrid = mImSetIdxGridScroller->ImSetIdxGrid();
            mImSetIdxGrid->SetImageSetIdxGridListener(this);
            //mImSetIdxGrid->ShowNames(false);
            mImSetIdxGrid->ShowDims(false);
        }

        mDataDoc->SetConcept(0);
    }

    virtual void
    HandleNewFile()
    {
        int concept = mDataDoc->GetConceptIdx();
        if (concept != mStringSelector->GetCurrentStringIdx())
            mStringSelector->SetCurrentString(concept, true);
        if (concept == mCurConcept)
            return;

        mCurConcept = concept;
        if (mImagesSet)
        {
            mImagesSet->RemoveImages();
            mImagesSet->SetFirstVisY(0, true);
        }
        if (mImSetIdxGrid)
            mImSetIdxGrid->Clear();
        mVisibleKeys.clear();
        Core::VideoSet::Keyframes* keys = mSegDoc ? mSegDoc->GetKeyframes() : 0;
        if (mSegDoc && !keys)
            return;

        Core::ImageSet::ImageSet* imSet = 
            mSegDoc ? mSegDoc->GetImSetKeyframes(true) : mIxsDoc->GetImageSet();
        if (!imSet)
            return;

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        Util::Database* db;
        String conceptTab = mDataDoc->GetConcept()+".tab";
        String fName;
        if (mSegDoc)
        {
            Core::VideoSet::VideoSet* vidSet = mSegDoc->GetVideoSet();
            fName = vidSet->GetFilePathAnnotation(QUID_CLASS_FRAME, mAnnoSet,
                                                  conceptTab, false, false);
            db = vidSet->GetDatabase();
        }
        if (mIxsDoc)
        {
            Core::ImageSet::ImageSet* ixsSet = mIxsDoc->GetImageSet();
            fName = ixsSet->GetFilePathAnnotation(QUID_CLASS_IMAGE, mAnnoSet,
                                                  conceptTab, false, false);
            db = ixsSet->GetDatabase();
        }
        if (fName.empty())
            return;

        if (mAnno)
            delete mAnno;
        mAnno = Core::Table::AnnotationTable::MakeFromFile
                                             (mDataDoc->GetConcept(),fName, db);
#else // REPOSITORY_USED
        typedef Persistency::AnnotationTableLocator AnnoLoc;
        AnnoLoc loc;
        if (mSegDoc)
        {
            Core::VideoSet::VideoSet* vidSet = mSegDoc->GetVideoSet();
            loc = AnnoLoc(vidSet->GetLocator(), QUID_CLASS_FRAME, mAnnoSet,
                          mDataDoc->GetConcept());
        }
        if (mIxsDoc)
        {
            Core::ImageSet::ImageSet* ixsSet = mIxsDoc->GetImageSet();
            loc = AnnoLoc(ixsSet->GetLocator(), QUID_CLASS_IMAGE, mAnnoSet,
                          mDataDoc->GetConcept());
        }
        if (! Persistency::AnnotationTableRepository().Exists(loc))
            return;

        if (mAnno)
            delete mAnno;
        mAnno = Persistency::AnnotationTableRepository().Get(loc);
#endif // REPOSITORY_USED
        int sz = mAnno->Size();
        int maxNr = mImagesSet ? Min(sz, 1000) : sz;
        //int maxNr = Min<int>(mAnno->Size(), 1000);
        int nrFound = 0;
        int s = 0;
        while ((s < mAnno->Size()) && (nrFound < maxNr))
        {
            if (mAnno->IsPositive(s))
            {
                Quid q = mAnno->Get1(s);
                int keyfr = keys ? keys->GetFrameId(q) : mAnno->GetIndex(q);
                if (keyfr != -1)
                {
                    if (mImagesSet)
                        mImagesSet->AddImage(keyfr, imSet);
                    if (mImSetIdxGrid)
                        mImSetIdxGrid->AddImageSetIdx(imSet,keyfr);
                    mVisibleKeys.push_back(keyfr);
                    nrFound++;
                }
            }
            s++;
        }
        if (mImSetIdxGrid)
            mImSetIdxGrid->UpdateLayout(true);
        ILOG_INFO("Found " << nrFound << " of " << mAnno->GetNrPositive()
                  << " positive annotations");
    }

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

    void HandleImageSelectionEvent(int imIndex)
    {
        int keyfr = mVisibleKeys[imIndex];
        if (mSegDoc)
            mSegDoc->GotoKeyfr(keyfr);
        if (mIxsDoc)
            mIxsDoc->CursorToFile(keyfr);
        AllHandleNewCursor(Core::Database::LEVEL_SHOT, false);
    }

    virtual void
    ImageSelectionEvent(ImagesWindow* src, int imIndex, void* listenerData)
    {
        HandleImageSelectionEvent(imIndex);
    }

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

private:

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

    String                   mAnnoSet;
    int                      mCurConcept;
    AnnotationTable*         mAnno;
    std::vector<int>         mVisibleKeys;
    OglGui::StringSelector*  mStringSelector;
    ImageSet*                mImagesSet;
    ImageSetIdxGridScroller* mImSetIdxGridScroller;
    ImageSetIdxGrid*         mImSetIdxGrid;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(AnnotationTableGui, Visualization);

} // namespace Visualization
} // namespace Impala

#endif

---