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

---

ThreadSet.h

Go to the documentation of this file.

#ifndef Impala_Core_Trec_ThreadSet_h
#define Impala_Core_Trec_ThreadSet_h

#include "Core/Trec/ThreadVisualSimilarity.h"
#include "Core/Trec/ThreadBookmarked.h"
#include "Core/Trec/ThreadTime.h"
#include "Core/Trec/ThreadRank.h"
#include "Core/Trec/ThreadShots.h"
#include "Core/Trec/ThreadHistory.h"
#include "Core/Trec/ThreadVirtual.h"
#include "Core/ImageSet/ImageSet.h"
#include "Core/VideoSet/Segmentation.h"
#include "Core/VideoSet/Keyframes.h"

namespace Impala {
namespace Core {
namespace Trec {

class ThreadSet
{
public:

    ThreadSet(VideoSet::Segmentation* shots, VideoSet::Keyframes* keyframes,
              ImageSet::ImageSet* imSetThumb, ImageSet::ImageSet* imSetKey)
    {
        mShots = shots;
        mKeyframes = keyframes;
        mImSetThumb = imSetThumb;
        mImSetKey = imSetKey;
    }

    int
    GetNrThreads()
    {
        return mThreads.size();
    }

    Thread*
    GetThread(int idx)
    {
        if ((idx >= 0) && (idx < mThreads.size()))
            return mThreads[idx];
        return 0;
    }

    std::list<Thread*>
    GetThreadsByType(int type)
    {
        std::list<Thread*> results;
        for (int i=0; i < mThreads.size(); i++) {
            if (mThreads[i]->GetType() == type)
                results.push_back(mThreads[i]);
        }
        return results;
    }

    Thread*
    GetThreadByName(CString name)
    {
        for (int i=0; i < mThreads.size(); i++) {
            if (mThreads[i]->GetName() == name)
                return mThreads[i];
        }
        return NULL;
    }

    void
    CopyToShotsThread(Thread *input, CString output)
    {
        std::list<ShotResult> list;
        if (input != 0 && GetThreadByName("shots_" + output) == 0)
        {
            ILOG_DEBUG("Copying thread " << input->GetName() << " to shots_" <<
                       output<<" (" << input->GetLength() << " shots to copy)");
            for (int i=0; i<input->GetLength(); i++)
            {
                ShotResult r;
                r.shotid = input->GetShot(i);
                r.rank = i+1;
                r.score = 1.0;
                list.push_back(r);
            }
            AddThreadShots(output, list);
        }
    }

    void
    AddThreadTime()
    {
        mThreads.push_back(new ThreadTime(mShots));
    }

    void
    AddThreadRank(Table::SimilarityTableSet* simSet, int simId)
    {
        mThreads.push_back(new ThreadRank(mShots, mKeyframes, simSet, simId));
    }

    void
    AddThreadVisualSimilarity(CString feature)
    {
        ThreadVisualSimilarity* thread = 
            new ThreadVisualSimilarity(feature, mKeyframes);
        if (thread->GetValid())
            mThreads.push_back(thread);
    }

    void
    AddThreadShots(CString name, std::list<ShotResult> shotlist)
    {
        mThreads.push_back(new ThreadShots(name, shotlist, mShots, mKeyframes));
    }

    void
    AddThreadShots(CString name, std::list<KeyframeResult> keyframelist)
    {
        mThreads.push_back(new ThreadShots(name,keyframelist,mShots,mKeyframes));
    }

    void
    AddThreadBookmarked(VideoSet::TableShots* bookmarked)
    {
        mThreads.push_back(new ThreadBookmarked(bookmarked));
    }

    void
    AddThreadBookmarked(CString identifier)
    {
        mThreads.push_back(new ThreadBookmarked(0, "bookmarked_" + identifier));
    }

    void
    AddThreadHistory()
    {
        mThreads.push_back(new ThreadHistory());
    }

    void
    AddThreadVirtual(CString identifier)
    {
        mThreads.push_back(new ThreadVirtual(identifier));
    }

    void
    RemoveThread(CString threadname)
    {
        std::vector<Thread*>::iterator i;
        bool somethingerased = true;
        while (somethingerased)
        {
            somethingerased = false;
            for (i = mThreads.begin(); i != mThreads.end(); i++)
            {
                if ((*i) && (*i)->GetName() == threadname)
                {
                    Thread *d = (*i);
                    mThreads.erase(i);
                    delete d;
                    ILOG_DEBUG("erased thread " << threadname);
                    somethingerased = true;
                    break;
                }
            }
        }
    }

    void
    RemoveShotThreads()
    {
        std::vector<Thread*>::iterator i;
        bool somethingerased = true;
        while (somethingerased)
        {
            somethingerased = false;
            for (i = mThreads.begin(); i != mThreads.end(); i++)
            {
                if ((*i) && (*i)->GetName().find("shots_") != String::npos)
                {
                    ILOG_DEBUG("erased thread " << (*i)->GetName());
                    delete *i;
                    mThreads.erase(i);
                    somethingerased = true;
                    break;
                }
            }
        }
    }

    VideoSet::Segmentation*
    GetSegmentation()
    {
        return mShots;
    }

    String
    GetShotName(int shot)
    {
        return mShots->GetName(shot);
    }

    VideoSet::Keyframes*
    GetKeyframes()
    {
        return mKeyframes;
    }

    /* warning: improperly named: this actually returns the RKF for a shot ID */
    Core::Array::Array2dVec3UInt8*
    GetKeyframe(int shot)
    {
        ILOG_WARN("GetKeyframe: deprecated warning: " <<
                  "use GetImageByShotID instead.");
        return GetImageByShotID(shot);
    }

    Core::Array::Array2dVec3UInt8*
    GetImageByShotID(int shot, bool fromKeyframes=false)
    {
        if (!mKeyframes || !mImSetThumb)
            return 0;
        int key = mKeyframes->GetShotRKF(shot);
        // QUESTION: isn't it better to show the RKF?
        // int key = mKeyframes->GetFirstKeyframeShot(shot);
        if (fromKeyframes && mImSetKey)
            return mImSetKey->GetImage(key);
        return mImSetThumb->GetImage(key);
    }

    Core::Array::Array2dVec3UInt8*
    GetImageByKeyframeID(int keyframe, bool fromKeyframes= false)
    {
        if (!mKeyframes || !mImSetThumb)
            return 0;
        if (fromKeyframes && mImSetKey)
            return mImSetKey->GetImage(keyframe);
        return mImSetThumb->GetImage(keyframe);
    }

    int
    GetShotRKF(int shot)
    {
        if (!mKeyframes)
            return -1;
        return mKeyframes->GetShotRKF(shot);
        //return mKeyframes->GetFirstKeyframeShot(shot);
    }

    ImageSet::ImageSet*
    GetImageSetThumbnails()
    {
        return mImSetThumb;
    }

    ImageSet::ImageSet*
    GetImageSetKeyframes()
    {
        return mImSetKey;
    }

private:

    std::vector<Thread*>    mThreads;
    VideoSet::Segmentation* mShots;
    VideoSet::Keyframes*    mKeyframes;
    ImageSet::ImageSet*     mImSetKey;
    ImageSet::ImageSet*     mImSetThumb;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(ThreadSet, Core.Trec);

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

#endif

---