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

---

ShotResultPreviewBar.h

Go to the documentation of this file.

#ifndef Impala_Visualization_GUI_ShotResultPreviewBar_h
#define Impala_Visualization_GUI_ShotResultPreviewBar_h

#include "PreviewBar.h"

#include "Core/Trec/ShotResult.h"
#include "Core/Trec/KeyframeResult.h"

#include "Core/ImageSet/ImageSet.h"
#include "Core/VideoSet/Segmentation.h"

namespace Impala {
namespace Visualization {
namespace GUI {

//using namespace OglGui;

class ShotResultPreviewBar : public PreviewBar
{
public:
    typedef Core::Trec::ShotResult              ShotResult;
    typedef Core::Trec::KeyframeResult          KeyframeResult;
    typedef std::list<ShotResult>               ShotResultList;
    typedef std::list<KeyframeResult>           KeyframeResultList;
    typedef Core::VideoSet::Segmentation        Segmentation;
    typedef Core::VideoSet::Keyframes           Keyframes;
    typedef Core::ImageSet::ImageSet            CoreImageSet;

    ShotResultPreviewBar(OglGui::Window* parent, int w, int h, String query,
                         ShotResultList results, Segmentation* shots,
                         Keyframes* keyframes, CoreImageSet* imSet,
                         bool selected, int thumbW, int thumbH,
                         double viewscale) :
        PreviewBar(parent, w, h, query, 1.0, selected)
    {
        Init(results, shots, keyframes, imSet, thumbW, thumbH, viewscale);
    }

    ShotResultPreviewBar(Window *parent, int w, int h, String query,
                         KeyframeResultList results, Segmentation* shots,
                         Keyframes* keyframes, CoreImageSet* imSet,
                         bool selected, int thumbW, int thumbH,
                         double viewscale) :
        PreviewBar(parent, w, h, query, 1.0, selected)
    {
        Init(results, shots, keyframes, imSet, thumbW, thumbH, viewscale);
    }


    ShotResultList GetShots()
    {
        return mShotResults;
    }

private:
    void GeneralInit(int type, int nrIm, int space, Segmentation* shots,
                     Keyframes *keyframes, int thumbW, int thumbH,
                     double viewscale)
    {
        SetType(type);

        mPreviewImages  = NULL;
        mShots          = shots;
        mKeyframes      = keyframes;
        mNrImOnRow      = 10; // Dummy default

        // images:
        if (nrIm == 0)
            return;

        if (H() < thumbH) // adjusting scale to fit
            viewscale = (H()-2.0) / thumbH;

        mNrImOnRow = (W()-(space+4)) / (thumbW * viewscale) + 1;

        Window *wnd = new OglGui::Window(this, space, 0, W()-(space+4), H());
        if (debug)
            std::cout << " Preview: " << mName << ": " << thumbW << "x" <<
                         thumbH << "@" << viewscale << ", nr " <<
                         mNrImOnRow << std::endl;

        mPreviewImages = new Visualization::ImageSet(wnd, thumbW, thumbH,
                                                     viewscale,mNrImOnRow,1,0);
        mPreviewImages->ActivateInfoBox(false);
        mPreviewImages->SetImagesListener(this, 0);
    }

    void Init(ShotResultList results, Segmentation* shots, Keyframes *keyframes,
              CoreImageSet* imSet, int thumbW, int thumbH, double viewscale)
    {
        GeneralInit(10, results.size(), 170, shots, keyframes,
                    thumbW, thumbH, viewscale);

        mShotResults = results;

        // images:
        if (!mPreviewImages)
            return;

        int i=0;
        ShotResultList::iterator shot;
        for (shot = results.begin(); shot != results.end(); shot++)
        {
            if (debug)
                std::cout << shot->shotid << " (rank=" << shot->rank
                          << " score=" << shot->score << "): ";

            int shotID = shot->shotid; //shots->GetShotId(shot->shotname);
            if (shotID >= 0)
            {
                int frameID = keyframes->GetShotRKF(shotID);
                if (frameID >= 0)
                {
                    if (debug)
                        std::cout << "rkf = " << shotID << " frame = "
                                  << frameID << std::endl;
                    std::ostringstream m;
                    m << shot->rank << " " << shot->score << " " << frameID;
                    mPreviewImages->AddImage(imSet->GetImage(frameID), "Direct",
                                             m.str(), true);
                    if (++i >= mNrImOnRow)
                        break;
                }
            }
        }
    }

    void Init(KeyframeResultList results, Segmentation* shots,
              Keyframes *keyframes, CoreImageSet* imSet, int thumbW, int thumbH,
              double viewscale)
    {
        GeneralInit(11, results.size(), 120, shots, keyframes,
                    thumbW, thumbH, viewscale);

        mKeyResults = results;

        if (!mPreviewImages)
            return;

        int i=0;
        KeyframeResultList::iterator shot;
        for (shot = results.begin(); shot != results.end(); shot++)
        {
            if (debug)
                std::cout << shot->keyframeid << " (rank=" << shot->rank
                          << " score=" << shot->score << "): ";

            int frameID = shot->keyframeid;
            if (frameID >= 0)
            {
                std::ostringstream m;
                m << shot->rank << " " << shot->score;
                mPreviewImages->AddImage(imSet->GetImage(frameID), "Direct",
                                         m.str(), true);
                if (++i >= mNrImOnRow)
                    break;
            }
        }
    }

    virtual int
    GetImageKeyframeID(int rank)
    {
        // ugly loop-implementation to allow for missing images:
        int foundrank = 0;

        if (mShotResults.size() > 0)
        {
            ShotResultList::iterator shot;
            for (shot=mShotResults.begin(); shot!=mShotResults.end(); shot++)
            {
                int shotID = shot->shotid;
                if (shotID >= 0)
                {
                    if (rank == foundrank)
                    {
                        // we found our match:
                        int frameID = mKeyframes->GetShotRKF(shotID);
                        if (debug)
                            std::cout << "FOUND shot " << shotID
                                      << " translates into " << frameID
                                      << std::endl;
    
                        return frameID;
                    }
                    foundrank ++;
                }
            }
        }
        else
        {
            KeyframeResultList::iterator shot;
            for (shot = mKeyResults.begin(); shot != mKeyResults.end(); shot++)
            {
                int frameID = shot->keyframeid;
                if (frameID >= 0)
                {
                    if (rank == foundrank)
                    {
                        // we found our match:
                        std::cout << "FOUND shot " << frameID << std::endl;
                        return frameID;
                    }
                    foundrank ++;
                }
            }
        }
        return -1;
    }

    // allow for select/deselect in this GUI component

    int                 mNrImOnRow;
    ShotResultList      mShotResults;
    KeyframeResultList  mKeyResults;
    Segmentation*       mShots;
    Keyframes*          mKeyframes;
};

} // GUI
} // Visualization
} // Impala

#endif

---