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

---

ImportAudioConcepts.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_ImportAudioConcepts_h
#define Impala_Core_VideoSet_ImportAudioConcepts_h

#include "Util/DatabaseReadString.h"
#include "Core/Table/SimilarityTableSet.h"
#include "Core/Table/QuidTable.h"
#include "Core/VideoSet/Reporter.h"
#include "Core/VideoSet/Segmentation.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/VideoSet/Mpeg7DocAudio.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class ImportAudioConcepts : public Listener
{
public:
    typedef Table::SimilarityTableSet SimilarityTableSet;
    typedef Table::SimilarityTableSet::SimTableType SimTableType;

    ImportAudioConcepts(Reporter* reporter, CmdOptions& options)
    {
        mReporter = reporter;
        if (options.GetNrArg() < 5)
        {
            ILOG_ERROR("Missing argument");
            return;
        }
        mConceptSet = options.GetArg(2);
        mModel = options.GetArg(3);
        mFeature = options.GetArg(4);
        mSegmentation = 0;
        mKeyframes = 0;
        mSimSet = 0;
    }

    virtual void
    HandleNewWalk(VideoSet* vs, Keyframes* keyframes, bool* keyframeMask)
    {
        mKeyframes = keyframes;
    }

    virtual void
    HandleNewWalk(VideoSet* vs, Segmentation* segmentation)
    {
        mSegmentation = segmentation;
    }

    virtual void
    HandleNewWalk(VideoSet* vs)
    {
        String fName = vs->GetFilePathAnnotation(mConceptSet, false, false);
        if (fName.empty())
        {
            ILOG_ERROR("Unable to read conceptSet");
            return;
        }
        std::vector<String> names;
        Util::DatabaseReadString(std::back_inserter(names), fName,
                                 vs->GetDatabase(), true);
        mSimSet = new SimilarityTableSet(names, 100);
    }

    virtual void
    HandleNewFile(VideoSet* vs, int fileId, Stream::RgbDataSrc* src)
    {
        String vidName = vs->GetFile(fileId);
        for (int c=0 ; c<mSimSet->NrTables() ; c++)
        {
            int startKey = mKeyframes->GetFirstKeyframeVideo(fileId);
            int nrKeys = mKeyframes->GetNrKeyframesVideo(fileId);
            if (c == 0)
            {
                Table::QuidTable* qTable = mSimSet->GetQuidTable();
                for (int k=0 ; k<nrKeys ; k++)
                {
                    int frameNr = mKeyframes->GetFrameNr(startKey + k);
                    Quid quid = vs->GetQuidFrame(fileId, frameNr);
                    qTable->Add(quid);
                }
            }
            String concept = mSimSet->GetName(c);
            SimTableType* table = mSimSet->GetSimTable(c);
            String fName = vs->GetFilePathMpeg7Concept(fileId, mConceptSet,
                                                       concept + ".xml",
                                                       false, true);
            for (int k=0 ; k<nrKeys ; k++)
                table->Add(0.0);
            if (! fName.empty())
            {
                ILOG_INFO("Reading " << fName);
                Mpeg7DocAudio mp7(fName, vs->GetDatabase());
                for (int s=0 ; s<mp7.NrSegments() ; s++)
                {
                    double sim = mp7.Confidence(s);
                    int startFrame = mp7.StartFrameReFraction(s, 25);
                    int endFrame = mp7.EndFrameReFraction(s, 25);
                    std::vector<int> shotList;
                    shotList = mSegmentation->GetShotIds(fileId, startFrame,
                                                         endFrame, 12);
                    for (int i=0 ; i<shotList.size() ; i++)
                    {
                        int shot = shotList[i];
                        int sKey = mKeyframes->GetFirstKeyframeShot(shot);
                        int nKey = mKeyframes->GetNrKeyframesShot(shot);
                        for (int k=sKey ; k<sKey+nKey ; k++) 
                            table->Set1(k, sim);
                    }
                }
            }
        }
    }

    virtual void
    HandleDoneWalk(VideoSet* vs)
    {
        mSimSet->ComputeRanks(true);
        mSimSet->Save(vs, mConceptSet, mModel, mFeature, true);
        delete mSimSet;
    }

private:

    Reporter*           mReporter;
    String              mConceptSet;
    String              mModel;
    String              mFeature;
    Segmentation*       mSegmentation;
    Keyframes*          mKeyframes;
    SimilarityTableSet* mSimSet;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(ImportAudioConcepts, Impala.Core.VideoSet);

} // namespace VideoSet
} // namespace Core
} // namespace Impala

#endif

---