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

---

IndexFeaturesSubset.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_IndexFeatures_Subset_h
#define Impala_Core_VideoSet_IndexFeatures_Subset_h

#include "Core/Feature/FeatureTable.h"
#include "Core/VideoSet/Reporter.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/Table/Select.h"
#include "Core/Table/Write.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class IndexFeaturesSubset : public Listener
{
public:

    IndexFeaturesSubset(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        mDef = Feature::FeatureDefinition(options.GetArg(2));
        mTable = 0;
        mKeyframes = 0;
        mKeyframeMask = 0;
        mWalkType = "unknown";

        mQuidList = options.GetString("subset","");
        mAnnoQuidTab = NULL;
        mbInitialize = false;

        mVerbose = options.GetBool("verbose", false);

    }

    ~IndexFeaturesSubset()
    {
        if (mAnnoQuidTab != NULL)
            delete mAnnoQuidTab;
    }

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

    virtual void
    HandleNewWalk(VideoSet* vs, Keyframes* keyframes, bool* keyframeMask)
    {
        mKeyframes = keyframes;
        mKeyframeMask = keyframeMask;
    }

    virtual void
    HandleDoneFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        String fName = vs->GetFilePathFeatureData(mWalkType, mDef,
                                                  fileId, false, -1, false,
                                                  false);
        if (fName.empty())
        {
            return;
        }
        Feature::FeatureTable tmp(mDef);
        Table::Read(&tmp, fName, vs->GetDatabase());
        if (mTable == 0)
        {
            mTable = new Feature::FeatureTable(mDef, 0,
                                               tmp.GetFeatureVectorLength());
        }

        // only read quid list once
        if (!mbInitialize)
        {
            mAnnoQuidTab = new Core::Table::QuidTable;
            //mQuidList = "Annotations/Genre/concepts_4genre.txt/HomeHighResolution_pos.tab";
            Core::Table::Read(mAnnoQuidTab, mQuidList, vs->GetDatabase());

            mAnnoTabSize = mAnnoQuidTab->Capacity();

            mbInitialize = true;
        }

        int nFeatureTabSize = tmp.Capacity();

        bool* mask = new bool[nFeatureTabSize];
        int nMatched = 0;

        // loop for each keyframe feature vectors
        for (int i=0; i<nFeatureTabSize; i++)
        {
            Quid q = tmp.Get1(i);

            bool bMatched = false;
            
            // loop for all annotation tables
            for (int j=0; j<mAnnoTabSize; j++)
            {
                Quid q2 = mAnnoQuidTab->Get1(j);

                if (q == q2)
                {
                    bMatched = true;
                    break;
                }
            }

            // set the mask file
            if (bMatched)
            {
                mask[i] = true;
                nMatched ++;
            }
            else
            {
                mask[i] = false;
            }
        }

        if (mVerbose)
        {
            std::cout << vs->GetFile(fileId) << " Mask: " << nMatched << " positives (out of ";
            std::cout << nFeatureTabSize << ")" << std::endl;
            for (int k=0; k<nFeatureTabSize; k++)
                std::cout << mask[k];
            std::cout << std::endl;
        }
        
        Table::Select(mTable, &tmp, mask, false);

        delete []mask;

    }

    virtual void
    HandleDoneWalk(VideoSet* vs)
    {
        String fName = vs->GetFilePathFeatureIndex(mDef, "", true, false);
        if (! fName.empty())
            Table::Write(mTable, fName, vs->GetDatabase(), true);
    }

private:

    Reporter*                  mReporter;
    Feature::FeatureDefinition mDef;
    Feature::FeatureTable*     mTable;
    Keyframes*                 mKeyframes;
    bool*                      mKeyframeMask;
    String                     mWalkType;

    String                     mQuidList;
    Core::Table::QuidTable*    mAnnoQuidTab;
    int                        mAnnoTabSize;
    bool                       mbInitialize;

    bool                       mVerbose;

};

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

#endif

---