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

---

VisualQueryEngine.h

Go to the documentation of this file.

#ifndef Impala_Core_Trec_VisualQueryEngine_h
#define Impala_Core_Trec_VisualQueryEngine_h

#include "Core/Geometry/Rectangle.h"

#include "Core/Trec/KeyframeResult.h"
#include "Core/Trec/ShotResult.h"
//#include "Sandbox/ork/XRegionQuery.h"
#include "Basis/ILog.h"

namespace Impala {
namespace Core {
namespace Trec {

class VisualQueryEngine {
public:
    typedef std::list<KeyframeResult>           KeyframeResultList;

    VisualQueryEngine(ThreadSet *threadset, int maxResults)
    {
        mThreadSet = threadset;
        mMaxResults = maxResults;
    }

    KeyframeResultList
    QueryByRegion(int keyframeID, Core::Geometry::Rectangle rect, int h, int w)
    {
        double top, left, bottom, right;
        top    = rect.mTop / (double)h;
        left   = rect.mLeft / (double)w;
        bottom = rect.mBottom / (double)h;
        right  = rect.mRight / (double)w;
        return QueryByRegion(keyframeID, left, top, right, bottom);
    }

    KeyframeResultList
    QueryByRegion(int keyframeID, float left, float top, float right, float bot)
    {
        ILOG_DEBUG("QueryByRegion: keyframe="<<keyframeID<< " (left=" << left <<
                   ", top=" << top<< ") x ( right=" << right<< ", bottom=" <<
                   bot<< ")");
        return QueryVisual(keyframeID, false);
/*        ILOG_STARTACTION("query by region", ILOG_LEVEL_SYSTEM);
        Sandbox::XRegionQuery *q = new Sandbox::XRegionQuery();
        KeyframeResultList results = q->query(keyframeID, left, top , right,
                                              bot, mThreadSet->GetKeyframes());
        ILOG_ENDACTION("query by region");
        return results; */
    }

    KeyframeResultList
    QueryVisual(int keyframeID, bool forcerecalculate = false)
    {
        return QueryVisual("fusionvissemgabor", keyframeID, forcerecalculate);
    }


    KeyframeResultList
    QueryVisual(std::string thread, int keyframeID, bool forcerecalculate=false)
    {
        Thread* visual = mThreadSet->GetThreadByName("visual_" + thread);
        // RvB: SaveGuard
        if (!visual)
        {
            KeyframeResultList results;
            return results;
        }
        return QueryVisual(visual, keyframeID, forcerecalculate);
    }

    KeyframeResultList
    QueryVisual(Thread *thread, int keyframeID, bool forcerecalculate = false,
                int maxToReturn = -1)
    {
        ThreadVisualSimilarity* threadVisual = (ThreadVisualSimilarity*) thread;
        VideoSet::Keyframes* keyFrames = mThreadSet->GetKeyframes();

        int oldMax = threadVisual->GetMaxReturned();
        threadVisual->SetMaxReturned(mMaxResults);

        int shotID = keyFrames->GetShotId(keyframeID);
        //int nrOfKeyFrames = keyFrames->Size();

        //if (forcerecalculate)
            thread->SetOrigin(shotID);
        int resultLen = thread->GetLength();
        if (maxToReturn >= 0 && maxToReturn < resultLen)
            resultLen = maxToReturn;

        KeyframeResultList results;
        std::map<int,bool> seen;
        for (int i = 0; i < resultLen; i++) {
            Trec::KeyframeResult r;
            int shot = threadVisual->GetShot(i); // according to current ranking
            if (shot < keyFrames->GetNrShots() && shot > -1) {
                r.keyframeid = keyFrames->GetShotRKF(shot);
                if (r.keyframeid != -1 && seen.find(r.keyframeid)==seen.end())
                {
                    seen[r.keyframeid] = true;
                    r.rank = i+1;
                    r.score = threadVisual->GetSimilarity(shot);
                    results.push_back(r);
                }
            }
            else
            {
                ILOG_WARN("Received incorrect shot from visual keyframe=" <<
                          keyframeID << " at position " << i);
                break; // SK: fix for datasets with less than 400 keyframes
            }
        }
        threadVisual->SetMaxReturned(oldMax);
        return results;
    }


private:
    ThreadSet*          mThreadSet;
    int                 mMaxResults;

   ILOG_VAR_DEC;
}; // class VisualQueryEngine

ILOG_VAR_INIT(VisualQueryEngine, Visualization.RotorBrowser);

}
}
}
#endif

---