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

---

ConcatFeatures.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_ConcatFeatures_h
#define Impala_Core_VideoSet_ConcatFeatures_h

#include "Persistency/FeatureTableSetRepository.h"
#include "Core/Feature/FeatureTableSet.h"
#include "Core/VideoSet/Reporter.h"
#include "Core/Table/Write.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class ConcatFeatures : public Listener
{
public:
    typedef Feature::FeatureList FeatureList;
    typedef Feature::FeatureDefinition FeatureDefinition;
    typedef Feature::FeatureTable FeatureTable;
    typedef Feature::FeatureTableSet FeatureTableSet;

    ConcatFeatures(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        if (FileNameExt(options.GetArg(2)) == "txt")
        {
            mSrcFileName = options.GetArg(2);
            mSrcDefs = mSrcFileName;
            mResultDef = FeatureDefinition(FileNameBase(mSrcFileName));
            ILOG_INFO("resultDef = " << mResultDef.AsString());
        }
        else
        {
            mResultDef = FeatureDefinition(options.GetArg(2));
            mSrcDefs = options.GetArg(3);
            for (int i=4 ; i<options.GetNrArg() ; i++)
                mSrcDefs += ";" + options.GetArg(i);
        }
        mWalkType = "unknown";
        mIsPartial = false;
    }

    virtual void
    HandleNewWalkPartial(VideoSet* vs, int startFrame, int stepSize,
                         int numberFrames)
    {
        mIsPartial = true;
        mNumberFrames = numberFrames;
    }

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

    virtual void
    HandleDoneFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        std::vector<String> defList;
        if (!mSrcFileName.empty())
        {
            String filePath;
            Util::Database* db;
            if (StringStartsWith(mSrcFileName, "..")) // assume "global"
            {
                db = &Util::Database::GetInstance();
                filePath = db->GetFilePath(mSrcFileName, false, false);
            }
            else // assume "local"
            {
                filePath = vs->GetFilePathFeatureData(mWalkType, mSrcFileName,
                                                      fileId, mIsPartial,
                                                      0, false, false);
                db = vs->GetDatabase();
            }
            Util::DatabaseReadString(std::back_inserter(defList), filePath,
                                     db, true);
            mSrcDefs = defList[0];
            for (int i=1 ; i<defList.size() ; i++)
                mSrcDefs += ";" + defList[i];
            ILOG_DEBUG("mSrcDefs = " << mSrcDefs);
        }

        FeatureTableSet* fSet = FeatureTableSet::MakeFromFile
            (mWalkType, false, mSrcDefs, vs, fileId, mIsPartial, mNumberFrames);
#else // REPOSITORY_USED
        Persistency::FeatureLocator loc(vs->GetLocator(), false, false,
                                        mWalkType, mSrcDefs,
                                        vs->GetContainerFile(fileId));
        if (mIsPartial)
            loc.SetNumberFrames(mNumberFrames);
        FeatureTableSet* fSet =
                Persistency::FeatureTableSetRepository().Get(loc);
#endif // REPOSITORY_USED
        if (fSet == 0)
            return;

        FeatureTable* res;
        String resName = mResultDef.AsString();
        if (resName == "vissem_proto_annotation_nrScales_2_nrRects_130" ||
            resName == "vissemgabor_proto_annotation_nrScales_2_nrRects_130")
        {
            ILOG_INFO("Using VissemHack to get original order in vector");
            res = fSet->ConcatTablesVissemHack(mResultDef);
        }
        else
        {
            res = fSet->ConcatTables(mResultDef);
        }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String fName = vs->GetFilePathFeatureData
            (mWalkType, mResultDef, fileId, false, -1, true, false);
        if ((res != 0) && (!fName.empty()))
        {
            Table::Write(res, fName, vs->GetDatabase(), true);
        }
#else // REPOSITORY_USED
        if (res != 0)
        {
            loc.SetFeatureDef(mResultDef);
            loc.SetNumberFrames(0);
            Persistency::FeatureTableRepository().Add(loc, res);
        }
#endif // REPOSITORY_USED
        fSet->Delete();
        delete fSet;
        delete res;
    }

private:

    Reporter*         mReporter;
    FeatureDefinition mResultDef;
    String            mSrcDefs;
    String            mSrcFileName;
    String            mWalkType;
    bool              mIsPartial;
    int               mNumberFrames;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(ConcatFeatures, Impala.Core.VideoSet);

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

#endif

---