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

---

DataFactory.h

Go to the documentation of this file.

#ifndef Impala_Core_DataFactory_h
#define Impala_Core_DataFactory_h

#include "Util/StlHelpers.h"
#include "Core/Table/Read.h"
#include "Core/Table/Write.h"
#include "Core/Table/AnnotationTable.h"
#include "Core/VideoSet/MakeVideoSet.h"
#include "Core/ImageSet/MakeImageSet.h"
#include "Core/VideoSet/FilterRkf.h"
#include "Core/Feature/FeatureDefinition.h"
#include "Core/Feature/FeatureTable.h"
#include "Core/Matrix/DistributedAccess.h"
#include "Core/Training/Classifier.h"
#include "Core/Feature/RandomTree.h"

namespace Impala
{
namespace Core
{

class DataFactory
{
public:
    DataFactory(Database::RawDataSet* set, Util::Database* db, int quidClass,
                String conceptSet, String modelType,
                Feature::FeatureDefinition fdef,
                String kernelMatrixName, int conceptStart, int conceptNumber)
    {
        mDataSet = set;
        mDb = db;
        mQuidClass = quidClass;
        mConceptSet = conceptSet;
        mModelType = modelType;
        mFeatureDef = fdef;
        mKernelMatrixName = kernelMatrixName;
        mConceptStart = conceptStart;
        mConceptNumber = conceptNumber;
        mDistributedAccess = 0;
    }

    virtual
    ~DataFactory()
    {
        if(mDistributedAccess)
        {
            mDistributedAccess->Unsubscribe();
            delete mDistributedAccess;
        }
    }

    Array::Array2dVec3UInt8*
    MakeImage(Quid q)
    {
        QuidObj qo(q);
        if(qo.Class() != mQuidClass)
        {
            ILOG_ERROR("MakeImage with quid of quidClass "<< qo.Class());
            return 0;
        }
        if(mQuidClass == QUID_CLASS_IMAGE)
        {
            return static_cast<ImageSet::ImageSet*>(mDataSet)->GetImage(qo.Id());
        }
        else
        {
            ILOG_WARNING("MakeImage not tested for videosets");
            Stream::RgbDataSrc* src =
                static_cast<VideoSet::VideoSet*>(mDataSet)->GetVideo(qo.Object());
            src->GotoFrame(qo.Id());
            Array::Array2dVec3UInt8* im = Array::ArrayCreate<Array::Array2dVec3UInt8>
                (src->FrameWidth(), src->FrameHeight(), 0, 0, src->DataPtr(), true);
            delete src;
            return im;
        }
    }
    
    std::vector<String>
    MakeConceptList()
    {
        std::vector<String> conceptList;
        String conceptFile = 
            mDataSet->GetFilePathAnnotation(mConceptSet, false, false);
        Util::DatabaseReadStrings(conceptList, conceptFile, mDb);

        /* old code to load just one concept; should we reinstate this?
        if (!options.GetString("concept").empty())
        {
            String con = options.GetString("concept");
            int idx = -1;
            for (int i=0 ; i<conceptList.size() ; i++)
                if (conceptList[i] == con)
                    idx = i;
            if (idx == -1)
            {
                ILOG_ERROR("Unable to find concept " << con << " in list");
                start = end = 0;
                return;
            }
            start = idx;
            number = 1;
        }
        */
        // trunkate the concept list according to conceptStart and conceptNumber
        Util::SubSelectInPlace(&conceptList, mConceptStart, mConceptNumber);
        return conceptList;
    }

    int
    FeatureTableCount() const
    {
        if(mQuidClass == QUID_CLASS_IMAGE)
            return mDataSet->NrDirs();
        else
            return mDataSet->NrFiles();
    }

    Feature::FeatureTable*
    MakeFeatureTable(int videoId)
    {
        String path;
        if(mQuidClass == QUID_CLASS_IMAGE)
            path = mDataSet->GetFilePathFeatureData
                (mFeatureDef, videoId, false, 0, false, false);
        else
            path = mDataSet->GetFilePathFeatureData
                ("Keyframes", mFeatureDef, videoId, false, 0, false, false);
        if(path.empty())
        {
            return 0;
        }

        ILOG_DEBUG_ONCE("read features(" << videoId << ")");
        Feature::FeatureTable* features =
            Feature::FeatureTable::MakeFromFile(mFeatureDef, path, mDb);
        ILOG_DEBUG_ONCE("done read features: "<< features->Size());
        return features;
    }

    Table::QuidTable*
    MakeAllFeatureQuids()
    {
        Table::QuidTable * quids = new Table::QuidTable();
        //ILOG_DEBUG("loop MakeAllFeatureQuids, count = "<< FeatureTableCount());
        for(int i=0 ; i<FeatureTableCount() ; ++i)
        {
            Feature::FeatureTable* f = MakeFeatureTable(i);
            //ILOG_DEBUG("size(f)="<< f->Size() <<", f[0][0]="<< QuidObj(f->Get1(0)));
            quids->Append(f->GetQuidTable());
            delete f;
        }
        ILOG_DEBUG("done loop: "<< quids->Size() <<" quids retrieved");
        return quids;
    }

    Table::QuidTable*
    MakeTrainFeatureQuids()
    {
        Table::QuidTable * quids = MakeAllFeatureQuids();
        ILOG_DEBUG("MakeTrainFeatureQuids(): got "<< quids->Size() <<" quids");
        if(quids->Size() > 0)
        {
            int oldSetId = QuidSet(quids->Get1(0));
            quids->SetQuidSet(mDataSet->GetSetId());
            if(mQuidClass != QUID_CLASS_IMAGE)
                VideoSet::FilterRkf(quids, static_cast<VideoSet::VideoSet*>(mDataSet));
            quids->SetQuidSet(oldSetId);
        }
        return quids;
    }

    Table::AnnotationTable*
    MakeAnnotation(String concept)
    {
        // load annotations
        String filename = mDataSet->GetFilePathAnnotation
            (mQuidClass, mConceptSet, concept + ".tab", false, false);
        if (filename.empty())
        {
            ILOG_ERROR_ONCE("could not find the annotation of " << concept);
            return 0;
        }
        Table::AnnotationTable* annotation = new Table::AnnotationTable;
        Read(annotation, filename, mDb);
        ILOG_DEBUG_ONCE("Annotations size: " << annotation->Size() );
        ILOG_DEBUG_ONCE("nr pos = "<< annotation->GetNrPositive() <<
                        "nr neg = "<< annotation->GetNrNegative());
        /*
        int maxV = mProperties->GetInt("maxVideoId");
        mAnnotation->SelectQuidObjectMaxId(maxV);
        int maxP = mProperties->GetInt("maxPosPerVideo");
        mAnnotation->SelectQuidObjectMaxPositive(maxP);
        int maxN = mProperties->GetInt("maxNegPerVideo");
        mAnnotation->SelectQuidObjectMaxNegative(maxN);
        double pos = mAnnotation->GetNrPositive();
        double neg = mAnnotation->GetNrNegative();
        ILOG_DEBUG_ONCE(pos << " positive and " << neg << " negative annotations");
        ILOG_DEBUG_ONCE("total size of annotable = " << mAnnotation->Size());
        */
        return annotation;
    }

    bool
    CanMakeBestFile(String concept)
    {
        String filename = mDataSet->GetFilePathConceptModel
            (mConceptSet, mModelType, mFeatureDef, concept+".best",true,true);
        if(filename == "")
            return false;
        return true;
    }

    bool
    CanMakeConceptModel(String concept)
    {
        String filename = mDataSet->GetFilePathConceptModel
            (mConceptSet, mModelType, mFeatureDef, concept+".model",true,true);
        if(filename == "")
            return false;
        return true;
    }

    Util::IOBuffer*
    MakeBestFile(String concept, bool toWrite)
    {
        String name = concept+".best";
        String filename = mDataSet->GetFilePathConceptModel
            (mConceptSet, mModelType, mFeatureDef, name, toWrite, true);
        if(filename == "")
            return 0;
        ILOG_INFO("MakeBestFile: opening this filename: "<<filename);
        Util::IOBuffer* buf = mDb->GetIOBuffer(filename, !toWrite, false, "tmp", 0, true);
        // perhaps we should do some checking?
        return buf;
    }

    Util::IOBuffer*
    MakeBestFileWrite(String concept)
    {
        String filename = mDataSet->GetFilePathConceptModel
            (mConceptSet, mModelType, mFeatureDef, concept+".best",
             true, false);
        if(filename == "")
            return 0;
        Util::IOBuffer* buf = mDb->GetIOBuffer(filename, false, false, "tmp", 0, true);
        // perhaps we should do some checking?
        return buf;
    }

    Util::IOBuffer*
    MakeAllParametersFile(String concept)
    {
        String filename = mDataSet->GetFilePathConceptModel
            (mConceptSet, mModelType, mFeatureDef, concept+".allparameters",
             true, false);
        if(filename == "")
            return 0;
        Util::IOBuffer* buf = mDb->GetIOBuffer(filename, false, false, "tmp", 0, true);
        // perhaps we should do some checking?
        return buf;
    }

    Database::RawDataSet*
    GetDataSet()
    {
        return mDataSet;
    }

    Matrix::DistributedAccess*
    GetDistributedAccess()
    {
        if(mDistributedAccess == 0)
        {
            if(Link::Mpi::NrProcs() == 1)
                mDistributedAccess = new Matrix::DistributedAccess
                    (mKernelMatrixName, mDataSet, 0, 0, 1);
            else
            {
                mDistributedAccess = new Matrix::DistributedAccess
                    (mKernelMatrixName, mDataSet, 0, 1, Link::Mpi::NrProcs() - 1);
                if(Link::Mpi::MyId() == 0)
                    mDistributedAccess->Subscribe();
            }
        }
        return mDistributedAccess;
    }

    void
    ServeDistributedAccess()
    {
        Matrix::DistributedAccess* da = GetDistributedAccess();
        da->StartEventLoop();
    }

    void
    WriteConceptModel(String concept, Training::Classifier* c)
    {
        String modelname = mDataSet->GetFilePathConceptModel
            (mConceptSet, mModelType, mFeatureDef, concept+".model", true, false);
        if(modelname == "")
        {
            ILOG_ERROR("Could not write " << concept << ".model");
        }
        else
            c->SaveModel(modelname, mDb);
    }

    void
    WriteScoreOnSelf(String concept, double score)
    {
        String filename = mDataSet->GetFilePathConceptModel
            (mConceptSet, mModelType, mFeatureDef, concept+".ScoreOnSelf",
             true, false);
        if(filename.empty())
        {
            ILOG_ERROR("Could not write " << concept << ".ScoreOnSelf");
            throw;
        }
        else
        {
            Util::IOBuffer* buf = mDb->GetIOBuffer(filename, false,false,"tmp", 0, true);
            buf->Puts(MakeString(score));
            delete buf;
        }
    }

    bool
    CanWriteCodebook()
    {
        return !mDataSet->GetFilePathCodebook(mFeatureDef, true, true).empty();
    }
    
    void
    WriteRandomForest(Feature::RandomTreeTable* forest)
    {
        String filename = mDataSet->GetFilePathRandomForest
            (mFeatureDef, true, false);
        if(filename.empty())
        {
            ILOG_ERROR("Could not write random forest for " <<
                       mFeatureDef.AsString());
            throw;
        }
        else
        {
            Util::IOBuffer* buf = mDb->GetIOBuffer(filename, false, false,"tmp", 0, true);
            Write(forest, buf, true);
            delete buf;
        }
    }
    
    void
    WriteCodebook(Feature::FeatureTable* forest)
    {
        String filename = mDataSet->GetFilePathCodebook
            (mFeatureDef, true, false);
        if(filename.empty())
        {
            ILOG_ERROR("Could not write random forest for " <<
                       mFeatureDef.AsString());
            throw;
        }
        else
        {
            Util::IOBuffer* buf = mDb->GetIOBuffer(filename, false, false,"tmp", 0, true);
            Write(forest, buf, true);
            delete buf;
        }
    }

    Feature::FeatureDefinition
    GetFeatureDefinition()
    {
        return mFeatureDef;
    }

private:
    void
    GetPartialTask(CmdOptions &options, std::vector<String> conceptList,
                        int &start, int &end)
    {
        ILOG_VAR(Samples.mainCrossValidate.GetPartialTask);
        end = 0;
        start = options.GetInt("start");
        int number = options.GetInt("number");
        if (!options.GetString("concept").empty())
        {
            String con = options.GetString("concept");
            int idx = -1;
            for (int i=0 ; i<conceptList.size() ; i++)
                if (conceptList[i] == con)
                    idx = i;
            if (idx == -1)
            {
                ILOG_ERROR("Unable to find concept " << con << " in list");
                start = end = 0;
                return;
            }
            start = idx;
            number = 1;
        }
        end = (number == -1) ? conceptList.size() : start + number;
        if (end > conceptList.size())
            end = conceptList.size();
    }


    Database::RawDataSet* mDataSet;
    Util::Database* mDb;
    int mQuidClass;
    int mConceptStart;
    int mConceptNumber;
    String mConceptSet;
    String mModelType;
    Feature::FeatureDefinition mFeatureDef;
    String mKernelMatrixName;
    Matrix::DistributedAccess* mDistributedAccess;

    ILOG_VAR_DECL;
};

ILOG_VAR_INIT(DataFactory, Impala.Core);

} //namespace Core
} //namespace Impala

#endif //Impala_Core_DataFactory_h

---