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

---

IndexConcepts.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_IndexConcepts_h
#define Impala_Core_VideoSet_IndexConcepts_h

#include "Core/VideoSet/Reporter.h"
#include "Persistency/SimilarityTableSetRepository.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;
    typedef Persistency::SimilarityTableSetLocator SimilarityTableSetLocator;
    typedef Persistency::SimilarityTableSetRepository SimilarityTableSetRepository;

    IndexConcepts(Reporter* reporter, CmdOptions& options, VideoSet* vs)
    {
        if (options.GetNrArg() < 5)
        {
            ILOG_ERROR("Missing argument");
            return;
        }
        mLoc = SimilarityTableSetLocator
            (vs->GetLocator(), false, "", options.GetArg(2), options.GetArg(3),
             options.GetArg(4), "");
        mSimSet = 0;
        mSegmentation = 0;
    }

    virtual void
    HandleNewWalk(VideoSet* vs, String walkType)
    {
        mLoc.SetWalkType(walkType);
    }

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

    virtual void
    HandleDoneFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        mLoc.SetContainer(vs->GetContainer(fileId));
        SimilarityTableSet* simSet = SimilarityTableSetRepository().Get(mLoc);
        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 = mLoc.GetFeature();
        if (mLoc.GetWalkType() != "Keyframes")
            resName = mLoc.GetWalkType() + "-" + resName;
        if (mSegmentation)
            resName = "shot" + resName;
        mLoc.SetInIndex(true);
        mLoc.SetFeature(resName);
        SimilarityTableSetRepository().Add(mLoc, mSimSet);
        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;
    }

    SimilarityTableSetLocator mLoc;
    SimilarityTableSet*       mSimSet;
    Segmentation*             mSegmentation;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(IndexConcepts, Impala.Core.VideoSet);

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

#endif

---