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

---

SelectFrames.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_SelectFrames_h
#define Impala_Core_VideoSet_SelectFrames_h

#include "Persistency/KeyframesRepository.h"
#include "Persistency/SegmentationRepository.h"
#include "Persistency/QuidTableRepository.h"
#include "Core/VideoSet/Reporter.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/VideoSet/Segmentation.h"
#include "Core/Table/QuidTable.h"
#include "Core/Table/Write.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class SelectFrames : public Listener
{
public:

    SelectFrames(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        if (options.GetNrArg() < 4)
        {
            ILOG_ERROR("Missing argument");
            return;
        }
        mQuidName = options.GetArg(2);
        mNrExtra = atol(options.GetArg(3));
        mQuids = new Table::QuidTable(100);
    }

    virtual void
    HandleNewWalk(VideoSet* vs)
    {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        mKeyframes = new Keyframes(vs, "keyframes");
        mSegmentation = new Segmentation(vs, "segmentation");
#else // REPOSITORY_USED
        Persistency::KeyframesLocator kLoc(vs->GetLocator(), "keyframes");
        mKeyframes = Persistency::KeyframesRepository().Get(kLoc, vs);
        Persistency::SegmentationLocator sLoc(vs->GetLocator(), "segmentation");
        mSegmentation = Persistency::SegmentationRepository().Get(sLoc, vs);
#endif // REPOSITORY_USED
        //mKeyframes->DumpGroups();
    }

    virtual void
    HandleNewShot(VideoSet* vs, int fileId, Stream::RgbDataSrc* src, int shotId)
    {
        mFrameNrs.clear();
        if(shotId == -1)
        {
            ILOG_WARN("shotId=-1 encountered in HandleNewShot... iFrame outside shot segmentation?");
        }
    }

    virtual void
    HandleNewFrame(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        if (src->CurIsIFrame())
            mFrameNrs.push_back(src->FrameNr());
    }

    virtual void
    HandleDoneShot(VideoSet* vs, int fileId, Stream::RgbDataSrc* src, int shotId)
    {
        int firstKey = mKeyframes->GetFirstKeyframeShot(shotId);
        int nrKey = mKeyframes->GetNrKeyframesShot(shotId);
        ILOG_DEBUG("firstkey=" << firstKey << " nrKey=" << nrKey << 
                   " shotId="<< shotId);
        std::vector<int> keyframes;
        for (int i=0 ; i<nrKey ; i++)
        {
            int frameNr = mKeyframes->GetFrameNr(firstKey + i);
            keyframes.push_back(frameNr);
        }
        //AddBegin(keyframes);
        AddBeginMiddleEnd(keyframes);
        std::sort(keyframes.begin(), keyframes.end());
        for (int i=0 ; i<keyframes.size() ; i++)
        {
            Quid q = vs->GetQuidFrame(fileId, keyframes[i]);
            mQuids->Add(q);
        }
    }

    virtual void
    HandleDoneWalk(VideoSet* vs)
    {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String fName = vs->GetFilePathVideoIndex("", mQuidName, true, false);
        if (!fName.empty())
            Core::Table::Write(mQuids, fName, vs->GetDatabase(), true);
#else // REPOSITORY_USED
        Persistency::QuidTableLocator loc(vs->GetLocator(), "VideoIndex",
                                          mQuidName);
        Persistency::QuidTableRepository().Add(loc, mQuids);
#endif // REPOSITORY_USED
        delete mQuids;
    }

private:

    void
    AddBegin(std::vector<int>& keyframes)
    {
        int nrAdded = 0;
        int i = 0;
        while ((nrAdded < mNrExtra) && (i < mFrameNrs.size()))
        {
            if (std::find(keyframes.begin(), keyframes.end(), mFrameNrs[i]) ==
                keyframes.end())
            {
                keyframes.push_back(mFrameNrs[i]);
                nrAdded++;
            }
            i++;
        }
    }

    void
    AddBeginMiddleEnd(std::vector<int>& keyframes)
    {
        int totalNr = mFrameNrs.size();
        int part = totalNr / 3;
        if (totalNr % 3 != 0)
            part++;  // begin and middle are more important
        std::vector<int> idxVec;
        for (int p=0 ; p<part ; p++)
        {
            for (int i=0 ; i<3 ; i++)
            {
                int idx = i*part + p;
                if (idx < totalNr)
                    idxVec.push_back(idx);
            }
        }

        int nrAdded = 0;
        int i = 0;
        while ((nrAdded < mNrExtra) && (i < idxVec.size()))
        {
            int frame = mFrameNrs[idxVec[i]];
            if (std::find(keyframes.begin(), keyframes.end(), frame) ==
                keyframes.end())
            {
                keyframes.push_back(frame);
                nrAdded++;
            }
            i++;
        }
    }

    Reporter*               mReporter;
    Keyframes*              mKeyframes;
    Segmentation*           mSegmentation;
    String                  mQuidName;
    int                     mNrExtra;
    std::vector<int>        mFrameNrs;
    Core::Table::QuidTable* mQuids;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(SelectFrames, Impala.Core.VideoSet);

} // namespace VideoSet
} // namespace Core
} // namespace Impala

#endif

---