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

---

TrecEngine.h

Go to the documentation of this file.

/***********************************************************************************
 *
 * Application: Investigator's Dashboard (MultimediaN project 6)
 * 
 * Semantic Video Search Engine
 *
 * Primary author(s): Ork
 *                  : 
 *                  : 
 ***********************************************************************************/

#ifndef Impala_Application_IDash_TrecEngine_h
#define Impala_Application_IDash_TrecEngine_h

#include "Basis/Logger.h"
#include "Basis/CmdOptions.h"

#include "Core/Trec/ThreadSet.h"
#include "Core/VideoSet/VideoSet.h"
#include "Core/VideoSet/Segmentation.h"
#include "Core/VideoSet/SegmentationDocument.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/ImageSet/ImageSet.h"
#include "Core/ImageSet/MakeImageSet.h"
#include "Core/VideoSet/MakeVideoSet.h"

#include "IDashQueryEngine.h"

namespace Impala {
namespace Application {
namespace IDash {

class TrecEngine
{
public:
    typedef Core::Trec::IDashQueryEngine            IDashQueryEngine;
    typedef Core::Trec::KeyframeResult              KeyframeResult;
    
    TrecEngine()
    {
        ILOG_SYSTEM("Loading Semantic Video Search Engine...");

        ILOG_STARTACTION("loading configuration", ILOG_LEVEL_INFO);
        LoadConfig();
        ILOG_ENDACTION("loading configuration");

        ILOG_STARTACTION("loading data", ILOG_LEVEL_INFO);
        LoadData();
        ILOG_ENDACTION("loading data");

        mQueryEngine = new IDashQueryEngine(ThreadSet());

    }


    // Engine Retrieval Functions:
    //
    // these functions map the engine to the GUI
    //
    Core::Trec::ThreadSet*
    ThreadSet()
    {
        return mThreadSet;
    }

    Core::VideoSet::SegmentationDocument*
    SegmentationDocument()
    {
        return mSegDoc;
    }

    Core::Table::SimilarityTableSet*
    GetConceptRanking()
    {
        return mConceptRanking;
    }


    int ImWidth()        { return mThumbWidth; }
    int ImHeight()       { return mThumbHeight; }
    int ImScale()        { return mThumbScale; }


    // Engine Actions:
    //
    void
    PerformQuery(std::list<std::string> querycomponents)
    {

        ILOG_DEBUG("Preparing query...");
        mQueryEngine->Clear();
        mQueryEngine->ProcessIDashQueryList(querycomponents);

        if (mQueryEngine->HasComponents()) {
            mThreadSet->RemoveThread("shots_initialquery");
    
            ILOG_DEBUG("Performing query...");
            mQueryEngine->GenerateThreadFromQuery("initialquery");
        }
    }

    void
    PerformVisualQuery(std::string threadname, int keyframe)
    {
        ILOG_DEBUG("Preparing visual query for " << threadname <<
                   " keyframe " << keyframe << "...");
        mQueryEngine->Clear();
        std::list<KeyframeResult> visuals =
            mVisualQueryEngine->QueryVisual(threadname.substr(7),keyframe,true);
        mThreadSet->RemoveThread("shots_initialquery");
        mThreadSet->AddThreadShots("initialquery", visuals);
    }


private:

    void
    LoadConfig()
    {
        CmdOptions& options = CmdOptions::GetInstance();
        std::string yearStr = options.GetString("year");
        mYear = atol(yearStr);

        mVideoSetName = options.GetString("videoSet");
        mImageStills = options.GetBool("imageStills");
        mKeyServer = options.GetString("keyServer");
        mConceptSetName = options.GetString("conceptSet");
        mConceptModel = options.GetString("conceptModel");
        mConceptFeature = options.GetString("conceptFeature");
    }

    void
    LoadData()
    {
        typedef Core::ImageSet::ImageSet ImageSet;

        CmdOptions& options = CmdOptions::GetInstance();

        // read the keyframes
        ILOG_STARTACTION("reading keyframes", ILOG_LEVEL_INFO);;
        ImageSet* imSetKeyfr =
           Core::ImageSet::MakeImageSet(options.GetString("imageSetKeyframes"));
        if (imSetKeyfr)
            imSetKeyfr->SetImageSrc(false, false, true);
        else
            ILOG_WARN( "No keyframes available" );
        ILOG_ENDACTION("reading keyframes");

        // read the thumbnails
        ILOG_STARTACTION("reading thumbnails", ILOG_LEVEL_INFO);
        String imSetThumbStr = options.GetString("imageSetThumbnails");
        ImageSet* imSetThumb =  Core::ImageSet::MakeImageSet(imSetThumbStr);
        if (imSetThumb)
        {
            imSetThumb->SetImageSrc(! options.GetBool("noArchive"),
                                    options.GetBool("imFileArchive"),
                                    options.GetBool("imSplitArchive"));

            //Core::Array::Array2dVec3UInt8* im = imSetThumb->GetImage(0);
            //mThumbWidth = im->CW();
            //mThumbHeight = im->CH();
            //delete im;

            // we set this manually to allow for different sizes:
            mThumbWidth = 360 / 1.5; //im->CW();
            mThumbHeight = 240 / 1.5; //im->CH();

            mThumbScale = 1.0;
        }
        else
            ILOG_WARN( "No thumbnails available" );
        ILOG_ENDACTION("reading thumbnails");
    
        // read the stills
        ILOG_STARTACTION("reading stills", ILOG_LEVEL_INFO);;
        ImageSet* imSetStill =
            Core::ImageSet::MakeImageSet(options.GetString("imageSetStills"));
        if (imSetStill)
            imSetStill->SetImageSrc(false, false, true);
        else
            ILOG_WARN( "No stills available" );
        ILOG_ENDACTION("reading stills");

        // read the videoset
        ILOG_STARTACTION("reading videoset", ILOG_LEVEL_INFO);
        mVidSet = Core::VideoSet::MakeVideoSet(mVideoSetName);
        ILOG_ENDACTION("reading videoset");

        // read the shots
        ILOG_STARTACTION("reading shots", ILOG_LEVEL_INFO);
        mShots = new Core::VideoSet::Segmentation(mVidSet, "segmentation");
        ILOG_ENDACTION("reading shots");

        // read the keyframe set
        ILOG_STARTACTION("reading keyframe set", ILOG_LEVEL_INFO);
        mKeyframes = new Core::VideoSet::Keyframes(mVidSet, "keyframes");
        ILOG_ENDACTION("reading keyframe set");

        mSegDoc = new Core::VideoSet::SegmentationDocument
            (mVidSet, mShots, mKeyframes, imSetKeyfr, imSetThumb, imSetStill);

        mThreadSet = new Core::Trec::ThreadSet(mShots, mKeyframes, imSetThumb, imSetKeyfr);
        mThreadSet->AddThreadTime();
        mThreadSet->AddThreadBookmarked(mSegDoc->GetBookmarked());
        mThreadSet->AddThreadHistory();

        // read the concepts
        if (mConceptSetName != "") {
            ILOG_STARTACTION("reading concept ranking", ILOG_LEVEL_INFO);
            try {
                mConceptRanking =
                    Core::Table::SimilarityTableSet::MakeFromFile(mVidSet,
                                                                  mConceptSetName, 
                                                                  mConceptModel, 
                                                                  mConceptFeature);
            } catch (std::length_error) {
                ILOG_ERROR("MakeFromFile threw std::length_error");
                ILOG_ERROR("Probable cause: there are no concepts in set '" << mConceptSetName << "'.");
                mConceptSetName = "";
                mConceptRanking = 0;
            }

            if (mConceptRanking) {
                ILOG_INFO("Found " << mConceptRanking->NrTables() << " concepts for this set.");
                for (int i=0; i< mConceptRanking->NrTables(); i++) {
                    mThreadSet->AddThreadRank(mConceptRanking, i);
                }
            }


            ILOG_ENDACTION("reading concept ranking");

        } else {
            ILOG_WARN("concept reading disabled. No concepts available.");
            mConceptRanking = 0;
        }

        // read the visual similarities:
        ILOG_STARTACTION("adding visual similarity", ILOG_LEVEL_INFO);
        
        ILOG_STARTACTION("adding visual similarity - Lab histograms", ILOG_LEVEL_INFO);
        mThreadSet->AddThreadVisualSimilarity("labhistogram");
        ILOG_ENDACTION("adding visual similarity - Lab histograms");

        ILOG_STARTACTION("adding visual similarity - Weibull", ILOG_LEVEL_INFO);
        mThreadSet->AddThreadVisualSimilarity("vissem");
        ILOG_ENDACTION("adding visual similarity - Weibull");

        ILOG_STARTACTION("adding visual similarity - Gabor", ILOG_LEVEL_INFO);
        mThreadSet->AddThreadVisualSimilarity("vissemgabor");
        ILOG_ENDACTION("adding visual similarity - Gabor");

        ILOG_STARTACTION("adding visual similarity - Fusion", ILOG_LEVEL_INFO);
        mThreadSet->AddThreadVisualSimilarity("fusionvissemgabor");
        ILOG_ENDACTION("adding visual similarity - Fusion");

        ILOG_ENDACTION("adding visual similarity");


        mVisualQueryEngine = new Core::Trec::VisualQueryEngine(mThreadSet, 400);


    }

    // Data
    Core::VideoSet::VideoSet*        mVidSet;
    Core::VideoSet::Segmentation*    mShots;
    Core::VideoSet::Keyframes*       mKeyframes;
    Core::Trec::ThreadSet*           mThreadSet;
    Core::Table::SimilarityTableSet* mConceptRanking;

    Core::VideoSet::SegmentationDocument* mSegDoc; // controls current shot

    int                             mThumbWidth;
    int                             mThumbHeight;
    double                          mThumbScale;
    std::string                     mConceptSetName;
    std::string                     mConceptModel;
    std::string                     mConceptFeature;

    // Computation
    IDashQueryEngine*               mQueryEngine;
    Core::Trec::VisualQueryEngine*  mVisualQueryEngine;

    // Configuration
    std::string                     mVideoSetName;
    bool                            mImageStills;
    std::string                     mKeyServer;
    int                             mYear;


    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TrecEngine, Application.IDash);



}
}
}

#endif

---