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

---

IndexConcepts.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_IndexConcepts_h
#define Impala_Core_VideoSet_IndexConcepts_h

#include "Core/Table/SimilarityTableSet.h"
#include "Core/VideoSet/Reporter.h"
#include "Core/VideoSet/Segmentation.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class IndexConcepts : public Listener
{
public:
    typedef Feature::FeatureDefinition FeatureDefinition;
    typedef Table::SimilarityTableSet SimilarityTableSet;
    typedef Table::SimilarityTableSet::SimTableType SimTableType;

    IndexConcepts(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        if (options.GetNrArg() < 5)
        {
            ILOG_ERROR("Missing argument");
            return;
        }
        mConceptFileName = options.GetArg(2);
        mModel = options.GetArg(3);
        mFeatureDef = FeatureDefinition(options.GetArg(4));
        mSimSet = 0;
        mSegmentation = 0;
    }

    virtual void
    HandleNewWalk(VideoSet* vs, String walkType)
    {
        mWalkType = walkType;
    }

    virtual void
    HandleNewWalk(VideoSet* vs, Segmentation* segmentation)
    {
        mSegmentation = segmentation;
    }

    virtual void
    HandleDoneFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        SimilarityTableSet* simSet = SimilarityTableSet::MakeFromFile
            (vs, mWalkType, mConceptFileName, mModel, mFeatureDef.AsString(),
             fileId);
        if (!simSet)
        {
            ILOG_ERROR("Could not read SimilarityTableSet for file " << fileId);
            return;
        }
        simSet->ChangeQuidObject(fileId);
        if (mSimSet == 0)
        {
            std::vector<String> names = simSet->GetNames();
            mSimSet = new SimilarityTableSet(names, 1000000);
        }
        if (mSegmentation)
        {
            SimilarityTableSet* rkfSet = MapSimilaritiesOnShots(simSet, fileId);
            mSimSet->Append(rkfSet);
            delete rkfSet;
        }
        else
        {
            mSimSet->Append(simSet);
        }
        delete simSet;
    }

    virtual void
    HandleDoneWalk(VideoSet* vs)
    {
        mSimSet->ComputeRanks(true);
        String resName = mFeatureDef.AsString();
        if (mWalkType != "Keyframes")
            resName = mWalkType + "-" + resName;
        if (mSegmentation)
            resName = "shot" + resName;
        mSimSet->Save(vs, mConceptFileName, mModel, resName, true);
        delete mSimSet;
    }

private:

    SimilarityTableSet*
    MapSimilaritiesOnShots(SimilarityTableSet* simSet, int vidId)
    {
        Table::QuidTable* frameQuids = simSet->GetQuidTable();
        int firstShot = mSegmentation->GetFirstShotVideo(vidId);
        int nrShots = mSegmentation->GetNrShotsVideo(vidId);
        SimilarityTableSet* res = new SimilarityTableSet(simSet->GetNames(),
                                                         nrShots);
        Table::QuidTable* shotQuids = res->GetQuidTable();
        for (int i=firstShot ; i<firstShot+nrShots ; i++)
        {
            Quid q = mSegmentation->GetQuidShot(i);
            shotQuids->Add(q);
        }
        for (int t=0 ; t<simSet->NrTables() ; t++)
        {
            SimTableType* frameSimTable = simSet->GetSimTable(t);
            SimTableType* shotSimTable = res->GetSimTable(t);
            int lastShot = -1;
            Real64 lastSim = 0;
            for (int i=0 ; i<frameSimTable->Size() ; i++)
            {
                Quid frameQ = frameQuids->Get1(i);
                Real64 frameSim = frameSimTable->Get1(i);
                int shot = mSegmentation->GetShotId(frameQ);
                if (shot != lastShot)
                {
                    if (lastShot != -1)
                    {
                        Quid check = mSegmentation->GetQuidShot(lastShot);
                        int rank = shotSimTable->Size();
                        if (check != shotQuids->Get1(rank))
                        {
                            ILOG_ERROR("Quids do not match");
                        }
                        shotSimTable->Add(lastSim);
                    }
                    lastSim = frameSim;
                    lastShot = shot;
                }
                else
                {
                    if (frameSim > lastSim)
                    {
                        lastSim = frameSim;
                    }
                }
            }
            if (lastShot != -1)
            {
                Quid check = mSegmentation->GetQuidShot(lastShot);
                int rank = shotSimTable->Size();
                if (check != shotQuids->Get1(rank))
                {
                    ILOG_ERROR("Quids do not match");
                }
                shotSimTable->Add(lastSim);
            }
            if (shotSimTable->Size() < shotQuids->Size())
            {
                ILOG_ERROR("Missing shot similarities for " <<
                           simSet->GetName(t));
                for (int i=shotSimTable->Size() ; i<shotQuids->Size() ; i++)
                    shotSimTable->Add(0.0);
            }
        }
        return res;
    }


    Reporter*           mReporter;
    String              mConceptFileName;
    String              mModel;
    FeatureDefinition   mFeatureDef;
    SimilarityTableSet* mSimSet;
    Segmentation*       mSegmentation;
    String              mWalkType;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(IndexConcepts, Impala.Core.VideoSet);

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

#endif

---