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

---

FeatureTableSet.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_FeatureTableSet_h
#define Impala_Core_Feature_FeatureTableSet_h

#include <vector>
#include "Basis/StringList.h"
#include "Core/Vector/SetPart.h"
#include "Core/Column/Copy.h"
#include "Core/Table/Append.h"
#include "Core/Feature/FeatureTable.h"
#include "Core/Database/RawDataSet.h"

namespace Impala
{
namespace Core
{
namespace Feature
{


// basically a wrapper around std::vector of FeatureTables.
// provides access to tables based on names or parameter (values).
class FeatureTableSet
{
public:

    FeatureTableSet()
    {
    }

    ~FeatureTableSet()
    {
        // no destruction of elements, as std::vector doesn't do it either
        //for (int i=0 ; i<mTables.size() ; i++)
        //    delete mTables[i];
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    // Read data from given dir, typically in FeatureIndex
    static FeatureTableSet*
    MakeFromFile(String dir, bool useName, String featureDefs,
                 Database::RawDataSet* dataSet = 0)
    {
        FeatureTableSet* res = new FeatureTableSet();
        StringList defList(featureDefs, ';');
        for (StringListCI i=defList.begin() ; i!=defList.end() ; i++)
        {
            FeatureDefinition def(*i);
            String fName = dir;
            if (useName)
                fName += "/" + def.GetName();
            Util::Database* db = &Util::Database::GetInstance();
            String path;
            if (dataSet != 0)
            {
                db = dataSet->GetDatabase();
                path = dataSet->GetFilePath(fName, def.AsString() + ".tab",
                                            false, false);
            }
            if (!path.empty())
                fName = path;
            else
                fName += "/" + def.AsString() + ".tab";
            ILOG_INFO("reading " << fName);
            FeatureTable* table = FeatureTable::MakeFromFile(def, fName, db);
            res->Add(table);
        }
        return res;
    }

    // Read data from FeatureData subdirectory, partial results
    // version for video sets
    static FeatureTableSet*
    MakeFromFile(String walkType, bool keyframesIsObsolete, String featureDefs,
                 Database::RawDataSet* dataSet, int fileId, bool partial,
                 int numberFrames)
    {
        FeatureTableSet* res = new FeatureTableSet();
        StringList defList(featureDefs, ';');
        for (StringListCI i=defList.begin() ; i!=defList.end() ; i++)
        {
            FeatureDefinition def(*i);
            FeatureTable* table = 0;
            int startFr = 0;
            bool done = false;
            while (!done)
            {
                bool silent = partial && (startFr != 0);
                String fName = dataSet->GetFilePathFeatureData
                    (walkType, def, fileId, partial, startFr, false, silent);
                if (!fName.empty())
                {
                    ILOG_INFO("reading " << fName);
                    Util::Database* db = dataSet->GetDatabase();
                    if (table == 0)
                    {
                        table = FeatureTable::MakeFromFile(def, fName, db);
                    }
                    else
                    {
                        FeatureTable* t = FeatureTable::MakeFromFile(def, fName,
                                                                     db);
                        Table::Append(table, t);
                        delete t;
                    }
                }
                else
                {
                    done = true;
                }
                if (!partial)
                    done = true;
                startFr += numberFrames;
            }
            if (table != 0)
                res->Add(table);
        }
        if (res->Size() == 0)
        {
            res->Delete();
            delete res;
            return 0;
        }
        return res;
    }

    // Read data from FeatureData subdirectory, partial results
    // version for image sets
    static FeatureTableSet*
    MakeFromFile(String featureDefs, Database::RawDataSet* dataSet, 
                 int dirId, bool partial, int numberFrames)
    {
        FeatureTableSet* res = new FeatureTableSet();
        StringList defList(featureDefs, ';');
        for (StringListCI i=defList.begin() ; i!=defList.end() ; i++)
        {
            FeatureDefinition def(*i);
            FeatureTable* table = 0;
            int startFr = (partial) ? 0 : -1;
            bool done = false;
            while (!done)
            {
                bool silent = partial && (startFr != 0);
                String fName = dataSet->GetFilePathFeatureData
                    (def, dirId, partial, startFr, false, silent);
                if (!fName.empty())
                {
                    ILOG_INFO("reading " << fName);
                    Util::Database* db = dataSet->GetDatabase();
                    if (table == 0)
                    {
                        table = FeatureTable::MakeFromFile(def, fName, db);
                    }
                    else
                    {
                        FeatureTable* t = FeatureTable::MakeFromFile(def, fName,
                                                                     db);
                        Table::Append(table, t);
                        delete t;
                    }
                }
                else
                {
                    done = true;
                }
                if (!partial)
                    done = true;
                startFr += numberFrames;
            }
            res->Add(table);
        }
        return res;
    }
#endif // REPOSITORY_USED

    void
    Delete() // requires "explicit call to destructor"
    {
        for (int i=0 ; i<mTables.size() ; i++)
            delete mTables[i];
        mTables.clear();
    }

    int
    Size()
    {
        return mTables.size();
    }

    int
    GetTotalFeatureVectorLength()
    {
        int res = 0;
        for (int i=0 ; i<Size() ; i++)
        {
            FeatureTable* table = GetTable(i);
            res += table->GetFeatureVectorLength();
        }
        return res;
    }

    // Checks whether all tables have the same Size.
    // If so, returns that size, otherwise returns -1
    int
    CheckEqualSize()
    {
        int size = -1;
        for (int i=0 ; i<Size() ; i++)
        {
            FeatureTable* table = GetTable(i);
            if (size == -1)
                size = table->Size();
            else if (size != table->Size())
                return -1;
        }
        return size;
    }

    void
    Add(FeatureTable* table)
    {
        mTables.push_back(table);
    }

    FeatureDefinition
    GetFeatureDefinition(int i) const
    {
        return mTables[i]->GetFeatureDefinition();
    }

    String
    GetDefinitionName(int i) const
    {
        return GetFeatureDefinition(i).GetName();
    }

    String
    GetDefinitionAsString(int i) const
    {
        return GetFeatureDefinition(i).AsString();
    }

    FeatureTable*
    GetTable(int i) const
    {
        return mTables[i];
    }

    FeatureTable*
    GetTable(FeatureDefinition def) const
    {
        for (int i=0 ; i<mTables.size() ; i++)
        {
            if (GetFeatureDefinition(i) == def)
                return mTables[i];
        }
        return 0;
    }

    // return table with given name
    FeatureTable*
    GetTable(String name) const
    {
        for (int i=0 ; i<mTables.size() ; i++)
            if (GetDefinitionName(i) == name)
                return mTables[i];
        return 0;
    }

    // return table with given feature parameters
    template <class C>
    FeatureTable*
    GetTable(String name, C val)
    {
        String str = MakeString(val);
        for (int i=0 ; i<mTables.size() ; i++)
        {
            FeatureDefinition def = GetFeatureDefinition(i);
            if (def.GetParameterValue(name) == str)
                return mTables[i];
        }
        return 0;
    }

    // return tables with given feature parameters
    template <class C>
    std::vector<FeatureTable*>
    GetTables(String name, C val)
    {
        std::vector<FeatureTable*> res;
        String str = MakeString(val);
        for (int i=0 ; i<mTables.size() ; i++)
        {
            FeatureDefinition def = GetFeatureDefinition(i);
            if (def.GetParameterValue(name) == str)
            {
                res.push_back(mTables[i]);
            }
        }
        return res;
    }

    // return table with given feature parameters
    template <class C1, class C2>
    FeatureTable*
    GetTable(String name1, C1 val1, String name2, C2 val2)
    {
        String str1 = MakeString(val1);
        String str2 = MakeString(val2);
        for (int i=0 ; i<mTables.size() ; i++)
        {
            FeatureDefinition def = GetFeatureDefinition(i);
            if (def.GetParameterValue(name1) == str1 &&
                def.GetParameterValue(name2) == str2)
            {
                return mTables[i];
            }
        }
        return 0;
    }

    // return tables with given feature parameters
    template <class C1, class C2>
    std::vector<FeatureTable*>
    GetTables(String name1, C1 val1, String name2, C2 val2)
    {
        std::vector<FeatureTable*> res;
        String str1 = MakeString(val1);
        String str2 = MakeString(val2);
        for (int i=0 ; i<mTables.size() ; i++)
        {
            FeatureDefinition def = GetFeatureDefinition(i);
            if (def.GetParameterValue(name1) == str1 &&
                def.GetParameterValue(name2) == str2)
            {
                res.push_back(mTables[i]);
            }
        }
        return res;
    }

    // return table with given feature parameters
    template <class C1, class C2, class C3>
    FeatureTable*
    GetTable(String name1, C1 val1, String name2, C2 val2,
             String name3, C3 val3)
    {
        String str1 = MakeString(val1);
        String str2 = MakeString(val2);
        String str3 = MakeString(val3);
        for (int i=0 ; i<mTables.size() ; i++)
        {
            FeatureDefinition def = GetFeatureDefinition(i);
            if (def.GetParameterValue(name1) == str1 &&
                def.GetParameterValue(name2) == str2 &&
                def.GetParameterValue(name3) == str3)
            {
                return mTables[i];
            }
        }
        return 0;
    }

    void
    SetEmpty()
    {
        for (int i=0 ; i<mTables.size() ; i++)
            mTables[i]->SetEmpty();
    }

    FeatureTable*
    ConcatTables(FeatureDefinition resultDef)
    {
        int totalLength = GetTotalFeatureVectorLength();
        int size = CheckEqualSize();
        if (size == -1)
        {
            ILOG_ERROR("Tables do not have same size");
            return 0;
        }
        FeatureTable* res = new FeatureTable(resultDef, size, totalLength);
        int dstColumn = 0;
        for (int i=0 ; i<Size() ; i++)
        {
            FeatureTable* table = GetTable(i);
            if (i == 0)
                Column::Copy(res->GetColumn1(), table->GetColumn1(), size, 0, 0);
            Vector::SetPart(res->GetColumn2(), table->GetColumn2(), dstColumn);
            dstColumn += table->GetFeatureVectorLength();
        }
        res->SetSize(size);
        return res;
    }

    // Hack to produce the orginal order of the Vissem feature vector
    FeatureTable*
    ConcatTablesVissemHack(FeatureDefinition resultDef)
    {
        int totalLength = GetTotalFeatureVectorLength();
        int size = CheckEqualSize();
        if (size == -1)
        {
            ILOG_ERROR("Tables do not have same size");
            return 0;
        }
        FeatureTable* res = new FeatureTable(resultDef, size, totalLength);
        int dstColumn = 0;
        for (int col=0 ; col<totalLength ; col++)
        {
            int feat = col / 30;
            int j = col % 30;
            int agg = j / 15;
            int anno = j % 15;
            FeatureTable* table = GetTable(anno * 4 + feat);
            if (col == 0)
                Column::Copy(res->GetColumn1(), table->GetColumn1(), size, 0, 0);
            table->GetColumn2()->SetSize(size);
            Vector::SetPart(res->GetColumn2(), table->GetColumn2(), agg, 1, col);
        }
        res->SetSize(size);
        return res;
    }

    void
    Dump(bool doTable)
    {
        for (int i=0 ; i<mTables.size() ; i++)
        {
            std::cout << "FeatureTable " << i
                      << ", def = " << GetDefinitionAsString(i)
                      << ", length = " << mTables[i]->GetFeatureVectorLength()
                      << std::endl;
            if (doTable)
                GetTable(i)->Dump();
        }
    }

private:

    std::vector<FeatureTable*> mTables;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(FeatureTableSet, Impala.Core.Feature);

} // namespace Feature
} // namespace Core
} // namespace Impala

#endif

---