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

---

Computor.h

Go to the documentation of this file.

#ifndef Impala_Core_Feature_Computor_h
#define Impala_Core_Feature_Computor_h

#include "Persistency/FeatureListRepository.h"
#include "Persistency/FeatureTableRepository.h"
#include "Persistency/LabelSetRepository.h"
#include "Basis/CmdOptions.h"
#include "Util/DatabaseWriteString.h"
#include "Util/DatabaseReadString.h"
#include "Core/Database/MakeRawDataSet.h"
#include "Core/Geometry/RectanglePyramid.h"
#include "Core/Geometry/RectanglePyramidPerDim.h"
#include "Core/Table/Read.h"
#include "Core/Table/Write.h"
#include "Core/Feature/FeatureTableSet.h"
#include "Core/Feature/LabelSet.h"

namespace Impala
{
namespace Core
{
namespace Feature
{


class Computor
{
public:
    typedef Persistency::FeatureLocator FeatureLocator;

    Computor(String name, CmdOptions& options)
    {
        mName = name;

        mPyramid = Geometry::RectanglePyramid
            (options.GetInt("borderWidth"),
             options.GetInt("nrRegionsPerDimMin"),
             options.GetInt("nrRegionsPerDimMax"),
             options.GetInt("nrRegionsStepSize"),
             -1, -1);

        mLazebnikPyramid = Geometry::RectanglePyramidPerDim
            (options.GetInt("borderWidth"),
             options.GetInt("nrLazebnikRegionsPerDimMinX", 1),
             options.GetInt("nrLazebnikRegionsPerDimMaxX", 1),
             options.GetInt("nrLazebnikRegionsStepSizeX", 1),
             options.GetInt("nrLazebnikRegionsPerDimMinY", 1),
             options.GetInt("nrLazebnikRegionsPerDimMaxY", 1),
             options.GetInt("nrLazebnikRegionsStepSizeY", 1),
             -1, -1,
             options.GetDouble("overlapLazebnikRegions", 0));

        mProtoDataFile = options.GetString("protoDataFile");
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
#else // REPOSITORY_USED
        mProtoLabels = new LabelSet();
#endif // REPOSITORY_USED
        mProtoLimit = -1;

        mFeatureTableSet = new FeatureTableSet();
        mProtoFeatureTableSet = new FeatureTableSet();
        mRegionFeatureTableSet = new FeatureTableSet();

        mPixelFeatureSetSize = -1; // these are to be set by derived classes
        mRegionDescriptorLength = -1;
    }

    virtual
    ~Computor()
    {
        mFeatureTableSet->Delete();
        mProtoFeatureTableSet->Delete();
        mRegionFeatureTableSet->Delete();
        delete mFeatureTableSet;
        delete mProtoFeatureTableSet;
        delete mRegionFeatureTableSet;
    }

    // inquiry

    String
    GetName() const
    {
        return mName;
    }

    bool
    IsClusterBased() const
    {
        return mProtoDataFile == "clusters";
    }

    String
    GetMaskSetBase() const
    {
        return mMaskSetBase;
    }

    virtual int
    GetNrPixelFeatureSets() const
    {
        return mScale.size();
    }

    int
    GetPixelFeatureSetSize() const // assumed to be constant for all sets
    {
        return mPixelFeatureSetSize;
    }

    virtual int
    GetNrRegionFeatureSets() const
    {
        return mPyramid.NrLevels();
    }

    virtual int
    GetRegionFeatureSetSize(int i) const
    {
        return mPyramid.NrRects(i);
    }

    int
    GetRegionDescriptorLength()
    {
        return mRegionDescriptorLength;
    }

    int
    GetRegionFeatureLength()
    {
        return GetPixelFeatureSetSize() * GetRegionDescriptorLength();
    }

    Geometry::RectanglePyramid
    GetPyramid()
    {
        return mPyramid;
    }

    String
    GetProtoDataFile()
    {
        return mProtoDataFile;
    }

    // FeatureTable part

    FeatureTableSet*
    GetFeatureTableSet()
    {
        return mFeatureTableSet;
    }

    FeatureTable*
    GetFeatureTable(FeatureDefinition def)
    {
        return mFeatureTableSet->GetTable(def);
    }

    FeatureTable*
    GetFeatureTable(FeatureDefinition def, int regionFeatureSet)
    {
        if (IsClusterBased())
            return GetFeatureTable(def);
        def.AddParameter(GetRegionFeatureDefName(regionFeatureSet),
                         GetRegionFeatureDefVal(regionFeatureSet));
        return GetFeatureTable(def);
    }

    void
    AddFeatureTable(FeatureDefinition def, int tableSize, int vecLen)
    {
        mFeatureTableSet->Add(new FeatureTable(def, tableSize, vecLen));
    }

    void
    MakeFeatureTableSet()
    {
        FeatureTableSet* protoSet = GetProtoFeatureTableSet();
        for (int i=0 ; i<protoSet->Size() ; i++)
        {
            FeatureTable* tab = protoSet->GetTable(i);
            if (IsClusterBased())
            {
                // 2 for avg and max
                int vecLen = 2 * tab->Size() * mLazebnikPyramid.TotalNrRects();
                AddFeatureTable(tab->GetFeatureDefinition(), 100, vecLen);
            }
            else
            {
                // 2 for avg and max
                int vecLen = 2 * 1 * mLazebnikPyramid.TotalNrRects();
                FeatureDefinition def = tab->GetFeatureDefinition();
                for (int r=0 ; r<GetNrRegionFeatureSets() ; r++)
                {   // with annotations features are the same for all regions
                    FeatureDefinition def2 = def;
                    def2.AddParameter(GetRegionFeatureDefName(r),
                                      GetRegionFeatureDefVal(r));
                    AddFeatureTable(def2, 100, vecLen);
                }
            }
        }
    }

    // add additional information to feature definitions before saving them
    virtual FeatureDefinition
    ExtendFeatureDefinition(FeatureDefinition def)
    {
        int limit = (mProtoLimit < 0) ? 0 : mProtoLimit;
        def.AddParameter("limit", limit);
        def.AddParameter("sp", mLazebnikPyramid.AsDefString());
        return def;
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    void
    WriteFeatureDefinitions(String fName, Util::Database* db)
    {
        std::vector<String> l;
        for (int i=0 ; i<mFeatureTableSet->Size() ; i++)
        {
            FeatureDefinition def = mFeatureTableSet->GetFeatureDefinition(i);
            def = ExtendFeatureDefinition(def);
            l.push_back(def.AsString());
        }
        Util::DatabaseWriteString(fName, db, l.begin(), l.end());
    }
#else // REPOSITORY_USED
    void
    WriteFeatureDefinitions(const Persistency::FeatureLocator& loc)
    {
        FeatureList l;
        for (int i=0 ; i<mFeatureTableSet->Size() ; i++)
        {
            FeatureDefinition def = mFeatureTableSet->GetFeatureDefinition(i);
            def = ExtendFeatureDefinition(def);
            l.push_back(def.AsString());
        }
        Persistency::FeatureListRepository().Add(loc, &l);
    }
#endif // REPOSITORY_USED

    // ProtoFeatureTableSet part

    FeatureTableSet*
    GetProtoFeatureTableSet()
    {
        return mProtoFeatureTableSet;
    }

    FeatureTable*
    GetProtoFeatureTable(int pixelFeatureSet, int regionFeatureSet,
                         String clusterType, String clusterVal)
    {
        String pName = GetPixelFeatureDefName(pixelFeatureSet);
        String pVal = GetPixelFeatureDefVal(pixelFeatureSet);
        String rName = GetRegionFeatureDefName(regionFeatureSet);
        String rVal = GetRegionFeatureDefVal(regionFeatureSet);
        return mProtoFeatureTableSet->GetTable(pName, pVal, rName, rVal,
                                               clusterType, clusterVal);
    }

    FeatureTable*
    GetProtoFeatureTable(int pixelFeatureSet, String anno)
    {
        String pName = GetPixelFeatureDefName(pixelFeatureSet);
        String pVal = GetPixelFeatureDefVal(pixelFeatureSet);
        FeatureDefinition def(GetName());
        def.AddParameter("proto", FileNameBase(mProtoDataFile));
        def.AddParameter("anno", anno);
        def.AddParameter(pName, pVal);
        FeatureTable* res = GetProtoFeatureTableSet()->GetTable(def);
        if (res == 0)
            AddProtoFeatureTable(def, 1, GetRegionFeatureLength());
        return GetProtoFeatureTableSet()->GetTable(def);
    }

    std::vector<FeatureTable*>
    GetProtoFeatureTables(int pixelFeatureSet)
    {
        String pName = GetPixelFeatureDefName(pixelFeatureSet);
        String pVal = GetPixelFeatureDefVal(pixelFeatureSet);
        return mProtoFeatureTableSet->GetTables(pName, pVal);
    }

    std::vector<FeatureTable*>
    GetProtoFeatureTables(int pixelFeatureSet, int regionFeatureSet)
    {
        String pName = GetPixelFeatureDefName(pixelFeatureSet);
        String pVal = GetPixelFeatureDefVal(pixelFeatureSet);
        String rName = GetRegionFeatureDefName(regionFeatureSet);
        String rVal = GetRegionFeatureDefVal(regionFeatureSet);
        return mProtoFeatureTableSet->GetTables(pName, pVal, rName, rVal);
    }

    void
    AddProtoFeatureTable(FeatureDefinition def, int tableSize, int vecLen)
    {
        mProtoFeatureTableSet->Add(new FeatureTable(def, tableSize, vecLen));
    }

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    void
    WriteProtoDefinitions(String fName, Util::Database* db)
    {
        std::vector<String> l;
        for (int i=0 ; i<mProtoFeatureTableSet->Size() ; i++)
            l.push_back(mProtoFeatureTableSet->GetDefinitionAsString(i));
        Util::DatabaseWriteString(fName, db, l.begin(), l.end());
    }

    void
    WriteProtoFeatureTableSet(Database::RawDataSet* dataSet)
    {
        Util::Database* db = dataSet->GetDatabase();
        std::vector<String> l;
        String lName = dataSet->GetFilePathPrototype
            (GetProtoDataFile(), GetName(), GetName() + "_all.txt", false, true);
        if (! lName.empty())
        {   // add to existing set, no duplicate check...
            Util::DatabaseReadString(std::back_inserter(l), lName, db, true);
        }
        else
        {
            lName = dataSet->GetFilePathPrototype
                (GetProtoDataFile(), GetName(), GetName() + "_all.txt", true,
                 false);
        }

        for (int i=0 ; i<mProtoFeatureTableSet->Size() ; i++)
        {
            FeatureDefinition def =
                mProtoFeatureTableSet->GetFeatureDefinition(i);
            l.push_back(def.AsString());
            String fName = dataSet->GetFilePathPrototype
                (GetProtoDataFile(), GetName(), def.AsString() + ".tab", true,
                 false);
            Table::Write(mProtoFeatureTableSet->GetTable(i), fName, db, true);
        }
        Util::DatabaseWriteString(lName, db, l.begin(), l.end());
        lName = dataSet->GetFilePathPrototype
            (GetProtoDataFile(), GetName(), GetName()+"_label.txt", true, true);
        if (!lName.empty())
            mProtoLabels.Save(lName, db);
    }
#else // REPOSITORY_USED
    void
    WriteProtoFeatureTableSet(Database::RawDataSet* dataSet)
    {
        FeatureList l;
        String container = mProtoDataFile + "/" + GetName();
        FeatureLocator loc(dataSet->GetLocator(), true, false, "",
                           GetName()+"_all.txt", container);
        if (Persistency::FeatureListRepository().Exists(loc))
            l = *(Persistency::FeatureListRepository().Get(loc));

        for (int i=0 ; i<mProtoFeatureTableSet->Size() ; i++)
        {
            FeatureDefinition def =
                mProtoFeatureTableSet->GetFeatureDefinition(i);
            l.push_back(def.AsString());
            FeatureLocator tLoc = loc;
            tLoc.SetFeatureDef(def);
            Persistency::FeatureTableRepository().Add
                (tLoc, mProtoFeatureTableSet->GetTable(i));
        }
        Persistency::FeatureListRepository().Add(loc, &l);
        loc.SetFeatureString(GetName()+"_label.txt");
        Persistency::LabelSetRepository().Add(loc, mProtoLabels);
    }
#endif // REPOSITORY_USED

    void
    ReadProtoFeatureTableSet(String protoSet, String maskSet)
    {
        mMaskSetBase = FileNameBase(maskSet);
        Database::RawDataSet* annoSet = Database::MakeRawDataSet(protoSet);
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        String fName = annoSet->GetFilePathPrototype
                (mProtoDataFile, GetName(), GetName()+"_all.txt", false, false);
        if (!maskSet.empty())
        {
            maskSet = annoSet->GetFilePathPrototype(mProtoDataFile, GetName(),
                                                    maskSet, false, false);
        }
        Util::Database* db = annoSet->GetDatabase();
        ReadFeatureTableSet(fName, db, mProtoFeatureTableSet, maskSet);
        fName = annoSet->GetFilePathPrototype
            (mProtoDataFile, GetName(), GetName()+"_label.txt", false, false);
        mProtoLabels.Load(fName, db);
        delete annoSet;
#else // REPOSITORY_USED
        String container = mProtoDataFile + "/" + GetName();
        FeatureLocator loc(annoSet->GetLocator(), true, false, "",
                           GetName()+"_all.txt", container);
        ReadFeatureTableSet(loc, mProtoFeatureTableSet, maskSet);
        loc.SetFeatureString(GetName()+"_label.txt");
        mProtoLabels = Persistency::LabelSetRepository().Get(loc);
        delete annoSet;
#endif // REPOSITORY_USED
    }

    void
    LimitProtoFeatureTableSize(int maxNr)
    {
        mProtoLimit = maxNr;
        for (int i=0 ; i<mProtoFeatureTableSet->Size() ; i++)
        {
            FeatureTable* t = mProtoFeatureTableSet->GetTable(i);
            if (t->Size() > maxNr)
            {
                ILOG_INFO("limiting " << t->GetFeatureDefinition().AsString()
                          << " to " << maxNr);
                t->SetSize(maxNr);
                t->GetColumn2()->SetSize(maxNr); // "bug" in Vector::Similarity
            }
        }
    }

    // RegionFeatureTableSet part

    FeatureTableSet*
    GetRegionFeatureTableSet()
    {
        return mRegionFeatureTableSet;
    }

    void
    AddRegionFeatureTable(FeatureDefinition def, int tableSize, int vecLen)
    {
        mRegionFeatureTableSet->Add(new FeatureTable(def, tableSize, vecLen));
    }

    FeatureTable*
    GetRegionFeatureTable(int pixelFeatureSet, int regionFeatureSet)
    {
        String pName = GetPixelFeatureDefName(pixelFeatureSet);
        String pVal = GetPixelFeatureDefVal(pixelFeatureSet);
        String rName = GetRegionFeatureDefName(regionFeatureSet);
        String rVal = GetRegionFeatureDefVal(regionFeatureSet);
        return mRegionFeatureTableSet->GetTable(pName, pVal, rName, rVal);
    }

    void
    MakeRegionFeatureTableSet()
    {
        int vecLen = GetRegionFeatureLength();
        for (int p=0 ; p<GetNrPixelFeatureSets() ; p++)
        {
            for (int r=0 ; r<GetNrRegionFeatureSets() ; r++)
            {
                String pName = GetPixelFeatureDefName(p);
                String pVal = GetPixelFeatureDefVal(p);
                String rName = GetRegionFeatureDefName(r);
                String rVal = GetRegionFeatureDefVal(r);
                FeatureDefinition def(GetName());
                def.AddParameter(pName, pVal);
                def.AddParameter(rName, rVal);
                AddRegionFeatureTable(def, GetRegionFeatureSetSize(r), vecLen);
            }
        }
    }

    // interface to derived classes

    virtual String
    GetPixelFeatureDefName(int idx)
    {
        return "scale";
    }

    virtual String
    GetPixelFeatureDefVal(int idx)
    {
        return MakeString(mScale[idx]);
    }

    virtual String
    GetRegionFeatureDefName(int idx)
    {
        return "rpd";
    }

    virtual String
    GetRegionFeatureDefVal(int idx)
    {
        return MakeString(GetPyramid().NrRectsPerDim(idx));
    }

    virtual FeatureTable*
    MakeProtoFeatureTable(int pixelFeatureSet, int regionFeatureSet,
                          String clusterType, String clusterVal) = 0;

    virtual void
    ReadPrototypes(String annoSet, String maskSet, int maxNr) = 0;

    virtual void
    ComputeRegionFeatures(Array::Array2dVec3UInt8* im, Quid quid) = 0;

    virtual void
    ComputeFeatures(Array::Array2dVec3UInt8* im, Quid quid) = 0;

protected:

    double
    GetScale(int i)
    {
        return mScale[i];
    }

    void
    AddScale(double scale)
    {
        mScale.push_back(scale);
    }

    void
    SetPixelFeatureSetSize(int nr)
    {
        mPixelFeatureSetSize = nr;
    }

    void
    SetRegionDescriptorLength(int len)
    {
        mRegionDescriptorLength = len;
    }

    String                           mName;
    std::vector<double>              mScale;
    Geometry::RectanglePyramid       mPyramid;
    Geometry::RectanglePyramidPerDim mLazebnikPyramid;
    String                           mMaskSetBase; // name of prototype maskSet

    String    mProtoDataFile; // name of the file with prototypes
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    LabelSet  mProtoLabels;   // unique labels within prototypes
#else // REPOSITORY_USED
    LabelSet* mProtoLabels;   // unique labels within prototypes
#endif // REPOSITORY_USED
    int       mProtoLimit;    // limit on the number of prototypes actually used

    int mPixelFeatureSetSize;    // number of pixel features (constant)
    int mRegionDescriptorLength; // length of region vector per pixel feature

private:

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    void
    ReadFeatureTableSet(String listName, Util::Database* db,
                        FeatureTableSet* tables, String maskSet)
    {
        std::vector<String> defList;
        Util::DatabaseReadString(std::back_inserter(defList), listName, db, true);
        std::vector<String> maskList;
        if (!maskSet.empty())
            Util::DatabaseReadString(std::back_inserter(maskList), maskSet, db,
                                     true);
        String dirName = FileNamePath(listName);
        for (int i=0 ; i<defList.size() ; i++)
        {
            if ((!maskSet.empty()) &&
                (std::find(maskList.begin(), maskList.end(), defList[i]) ==
                 maskList.end()))
            {
                ILOG_INFO_ONCE("skipping " << defList[i]);
                continue;
            }
            FeatureDefinition def(defList[i]);
            String fName = dirName + "/" + def.AsString() + ".tab";
            FeatureTable* tab = tables->GetTable(def);
            if (!tab)
            {
                tab = new FeatureTable(def);
                tables->Add(tab);
            }
            ILOG_INFO_ONCE("reading " << fName);
            Table::Read(tab, fName, db);
        }
        if (tables->Size() == 0)
            ILOG_ERROR("No tables read");
    }
#else // REPOSITORY_USED
    void
    ReadFeatureTableSet(const FeatureLocator& listLoc, FeatureTableSet* tables,
                        String maskSet)
    {
        String listName = listLoc.GetFeatureString();
        FeatureLocator tLoc = listLoc;
        FeatureList defList = *(Persistency::FeatureListRepository().Get(tLoc));
        FeatureList maskList;
        if (!maskSet.empty())
        {
            tLoc.SetFeatureString(maskSet);
            //Util::DatabaseReadString(std::back_inserter(maskList), maskSet, db,
            //                         true);
            maskList = *(Persistency::FeatureListRepository().Get(tLoc));
        }
        //String dirName = FileNamePath(listName);
        for (int i=0 ; i<defList.size() ; i++)
        {
            if ((!maskSet.empty()) &&
                (std::find(maskList.begin(), maskList.end(), defList[i]) ==
                 maskList.end()))
            {
                ILOG_DEBUG("skipping " << defList[i]);
                continue;
            }
            FeatureDefinition def(defList[i]);
            //String fName = dirName + "/" + def.AsString() + ".tab";
            FeatureTable* tab = tables->GetTable(def);
            if (!tab)
            {
                //tab = new FeatureTable(def);
                tLoc.SetFeatureDef(def);
                ILOG_DEBUG("reading " << def.AsString());
                tab = Persistency::FeatureTableRepository().Get(tLoc);
                tables->Add(tab);
            }
            else
            {
                //ILOG_INFO_ONCE("reading " << fName);
                //Table::Read(tab, fName, db);
                ILOG_INFO_ONCE("reading " << def.AsString());
                ILOG_ERROR("ReadFeatureTableSet: cannot do this yet");
            }
        }
        if (tables->Size() == 0)
            ILOG_ERROR("No tables read");
    }
#endif // REPOSITORY_USED

    FeatureTableSet* mFeatureTableSet; // typically similarity to prototypes
    FeatureTableSet* mProtoFeatureTableSet; // prototypical features
    FeatureTableSet* mRegionFeatureTableSet; // features per region

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(Computor, Impala.Core.Feature);

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

#endif

---