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

---

ThreadShots.h

Go to the documentation of this file.

#ifndef Impala_Core_Trec_ThreadShots_h
#define Impala_Core_Trec_ThreadShots_h

#include "Core/Trec/Thread.h"
#include "Core/Column/Find.h"

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

#include "Core/Table/AnnotationTable.h"

namespace Impala
{
namespace Core
{
namespace Trec
{

class ThreadShots : public Thread
{
public:

    ThreadShots(std::string identifier, std::list<ShotResult> shotlist,
                Core::VideoSet::Segmentation* shots,
                Core::VideoSet::Keyframes* keyframes) :
        Thread(std::string("shots_") + identifier)
    {
        mShots = new Core::Table::AnnotationTable();
        mSegmentation = shots;
        ConvertToTable(shotlist, shots);
    }

    ThreadShots(std::string identifier, std::list<KeyframeResult> keyframelist,
                Core::VideoSet::Segmentation* shots,
                Core::VideoSet::Keyframes* keyframes) :
        Thread(std::string("shots_") + identifier)
    {
        mShots = new Core::Table::AnnotationTable();
        mSegmentation = shots;
        ConvertToTable(keyframelist, shots, keyframes);
    }

    virtual int
    GetShot(int position)
    {
        if ((position < 0) || (position >= mShots->Size()))
            return -1;

        Quid s = mShots->Get1(position);
        return mSegmentation->GetShotId(s);
    }

    Real64
    GetShotScore(int position)
    {
        if ((position < 0) || (position >= mShots->Size()))
            return -1;
        return mShots->Get2(position);
    }

    virtual int
    GetLength()
    {
        return mShots->Size();
    }

    virtual int
    GetShotAt(int shot, int offset)
    {
        Quid shotquid = mSegmentation->GetQuidShot(shot);
        int r = Column::Find(mShots->GetColumn1(), shotquid, 0, mShots->Size());
        int dst = r + offset;
        if ((dst < 0) || (dst >= mShots->Size())) {
            return -1;
        }
        return mSegmentation->GetShotId(mShots->Get1(dst));
    }

    virtual int
    GetShotPosition(int shot)
    {
        if (shot<0) return -1;
        Quid shotquid = mSegmentation->GetQuidShot(shot);
        int r = Column::Find(mShots->GetColumn1(), shotquid, 0, mShots->Size());
        if (r == mShots->Size())
            return -1;
        return r;
    }

    virtual int
    GetType()
    {
        return SHOTS;
    }

private:

    void
    ConvertToTable(std::list<ShotResult> shotlist,
                   Core::VideoSet::Segmentation* shots)
    {
        std::list<ShotResult>::iterator i;
        std::map<int,bool> noduplicates;
        for (i = shotlist.begin(); i != shotlist.end(); i++)
        {
            if (i->shotid >= 0 &&
                noduplicates.find(i->shotid) == noduplicates.end())
            {
                Quid quid = shots->GetQuidShot(i->shotid);
                mShots->Add(quid, (Real64)i->score);
                noduplicates[i->shotid] = true;
            }
        }
    }

    void
    ConvertToTable(std::list<KeyframeResult> keyframelist,
                   Core::VideoSet::Segmentation* shots,
                   Core::VideoSet::Keyframes* keyframes)
    {
        std::list<KeyframeResult>::iterator i;
        std::map<int,bool> noduplicates;
        for (i = keyframelist.begin(); i != keyframelist.end(); i++)
        {
            if (i->keyframeid < 0)
                continue;

            int shot = keyframes->GetShotId(i->keyframeid);

            if (shot >= 0 &&
                noduplicates.find(shot) == noduplicates.end())
            {
                Quid quid = shots->GetQuidShot(shot);
                mShots->Add(quid, (Real64)i->score);
                noduplicates[shot] = true;
            }
        }
    }

    Core::Table::AnnotationTable* mShots;
    Core::VideoSet::Segmentation* mSegmentation;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(ThreadShots, Core.Trec);


} // namespace Trec
} // namespace Core
} // namespace Impala

#endif

---