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

---

FeatureTableRepositoryInMonet.h

Go to the documentation of this file.

#ifndef Impala_Persistency_FeatureTableRepositoryInMonet_h
#define Impala_Persistency_FeatureTableRepositoryInMonet_h

#include "Persistency/VideoSetRepository.h"
#include "Persistency/RepositoryInMonetDB.h"
#include "Core/Feature/FeatureTable.h"
#include "Persistency/FeatureLocator.h"
#include "Util/BinHex.h"

namespace Impala
{
namespace Persistency
{


class FeatureTableRepositoryInMonet
{
public:

    typedef Link::Monet::Connection Connection;
    typedef Core::Feature::FeatureTable FeatureTable;

    FeatureTableRepositoryInMonet()
    {
    }

    FeatureTable*
    Get(const FeatureLocator& loc)
    {
        if (loc.GetIsIndex())
        {
            ILOG_ERROR("Index not implemented (yet)");
            return 0;
        }
        if (loc.GetWalkType() != "Frames")
        {
            ILOG_ERROR("Only implemented for Frames");
            return 0;
        }

        Connection* conn = RepMonet().GetConnection(loc);

        String vidSetBase = FileNameBase(loc.GetDataSet());
        Core::Feature::FeatureDefinition def = loc.GetFeatureDef();
        Core::VideoSet::VideoSet* vidSet = VideoSetRepository().Get(loc);
        int fileIdx = vidSet->GetFileId(loc.GetContainer());
        Quid vidQuid = vidSet->GetQuidVideo(fileIdx, true);

        String query =
            "select fr.fragment_start, fv.vector \
             from feature_vector fv, fragment fr, file f, feature fe \
             where  f.quid = " + MakeString(vidQuid) + " and \
                    fr.media_id = f.media_id and \
                    fr.fragment_length = 1 and \
                    fr.keyframe = false and \
                    fe.feature_name = '" + loc.GetFeatureString() + "' and \
                    fe.feature_id = fv.feature_id and \
                    fv.fragment_id = fr.fragment_id and \
                    fv.file_id = f.file_id \
             order by fr.fragment_start;";

        MapiHdl hdl = conn->QueryPartStart(query);
        if (hdl == 0)
            return 0;

        //int nrRows = mapi_get_row_count(hdl);

        int* start = 0;
        int startSize = 0;
        if (!conn->QueryPartFetchInt(hdl, 0, start, startSize))
            return 0;

        std::vector<String> strs;
        if (!conn->QueryPartFetchString(hdl, 1, strs))
            return 0;


        //int numFieldsUsed = 2;
        //int fieldNrs[] = {0, 1};
        //int fieldTypes[] = {MAPI_INT, MAPI_VARCHAR};
        //void* recvBuffers[2];
        //if (!mCon->QueryPartFetchAll(hdl, numFieldsUsed, fieldNrs, fieldTypes, recvBuffers))
        //    return false;
        //int* theIntValues = recvBuffers[0];
        //String* theStringValues = recvBuffers[1];
        //int numRows = mapi_get_row_count(hdl);


        conn->QueryPartEnd(hdl);

        FeatureTable* res = 0;
        for (int i=0 ; i<startSize ; i++)
        {
            Quid q = vidSet->GetQuidFrame(fileIdx, start[i], true);

            size_t dataSize;
            UInt8* data = Util::Hex2Bin(strs[i], dataSize);        
            int n = dataSize / sizeof(Real64);
            Real64* realData = (Real64*) data;
            FeatureTable::VectorReal64 v(n, realData, true);

            if (res == 0)
                res = new FeatureTable(loc.GetFeatureDef(), strs.size(), n);
            res->Add(q, v);
            delete data;
        }

        if (res == 0)
            ILOG_ERROR("No features found");
        delete start;
        return res;
    }

    void
    Add(const FeatureLocator& loc, FeatureTable* tab)
    {
        if (loc.GetIsIndex())
        {
            ILOG_ERROR("Index not implemented (yet)");
            return;
        }
        if (loc.GetWalkType() != "Frames")
        {
            ILOG_ERROR("Only implemented for Frames");
            return;
        }

        Connection* conn = RepMonet().GetConnection(loc);

        String vidSetBase = FileNameBase(loc.GetDataSet());
        Core::VideoSet::VideoSet* vidSet = VideoSetRepository().Get(loc);
        int fileIdx = vidSet->GetFileId(loc.GetContainer());
        Quid vidQuid = vidSet->GetQuidVideo(fileIdx, true);

        String q = "select i_add_feature('" + loc.GetFeatureString() + "');";
        conn->Query(q, false, false);

        conn->Query("delete from i_bulk_feature_vector;", false, false);
        int totalSize = tab->Size();
        int bulkSize = 2000;
        Timer timer;
        for (int i=0 ; i<totalSize ; i+=bulkSize)
        {
            int left = totalSize - i;
            int nr = (left > bulkSize) ? bulkSize : left;
            String q = "copy " + MakeString(nr) +
                " records into i_bulk_feature_vector from stdin" +
                " using delimiters ' ';\n";
            for (int j=i ; j<i+nr ; j++)
            {
                Quid frameQuid = tab->Get1(j);
                if (QuidClass(frameQuid) != QUID_CLASS_FRAME)
                    ILOG_ERROR("Quid is not a frame");
                int frameNr = QuidId(frameQuid);
                FeatureTable::VectorReal64 v = tab->Get2(j);
                size_t dataSize = v.Size() * sizeof(Real64);
                UInt8* data = (UInt8*) v.GetData();
                String hexData = Util::Bin2Hex(data, dataSize);

                q += MakeString(vidQuid) + " " + MakeString(frameNr) + " "
                    + hexData + "\n";
            }
            conn->Query(q, false, false);
            ILOG_INFO("Did bulk " << i << " at " << timer.SplitTime());

            conn->Query("insert into feature_vector (fragment_id, file_id, \
                                                     feature_id, vector) \
                         select fr.fragment_id, f.file_id, fe.feature_id, \
                                bfv.vector \
                         from i_bulk_feature_vector bfv, file f, \
                              fragment fr, feature fe \
                         where bfv.quid = f.quid and \
                               f.media_id = fr.media_id and \
                               fr.fragment_start = bfv.fragment_start and \
                               fr.fragment_length = 1 and \
                               fr.keyframe = false and \
                               fe.feature_name = '" + loc.GetFeatureString() + "' \
                         order by bfv.fragment_start;", false, false);
            ILOG_INFO("Did insert select at " << timer.SplitTime());
            conn->Query("delete from i_bulk_feature_vector;", false, false);
        }
    }

private:

    RepositoryInMonetDB&
    RepMonet()
    {
        return RepositoryInMonetDB::GetInstance();
    }

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(FeatureTableRepositoryInMonet, Impala.Persistency);

} // namespace Persistency
} // namespace Impala

#endif

---