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

---

Keyframes.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_Keyframes_h
#define Impala_Core_VideoSet_Keyframes_h

#include "Persistency/ImageSetRepository.h"
#include "Basis/Quid.h"
#include "Core/Table/MakeGroupIndex.h"
#include "Core/VideoSet/VideoSet.h"
#include "Core/ImageSet/ImageSet.h"
#include "Core/Table/TableTem.h"
#include "Core/Table/Read.h"
#include "Core/Table/Write.h"
#include "Core/Table/RemoveRow.h"
#include "Core/Table/QuidTable.h"
#include "Core/Column/Find.h"
#include "Link/DiskImage/DiskImageFuncs.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


typedef Table::TableTem<Column::ColumnTem<Int32>,
                        Column::ColumnTem<Int32>,
                        Column::ColumnTem<Int32>,
                        Column::ColumnTem<String> > KeyframesBaseType;


class Keyframes : public KeyframesBaseType
{
    typedef Impala::Core::Table::GroupIndex GroupIndex;

public:

    Keyframes(VideoSet* vidSet, String name) : KeyframesBaseType(0)
    {
        mVidSet = vidSet;
        mName = name;
        mVideoGroups = 0;
        mShotGroups = 0;
        SetColName(1, "videoId");
        SetColName(2, "shotId");
        SetColName(3, "frameNr");
        SetColName(4, "name");
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        if (!mName.empty())
            Load();
#else // REPOSITORY_USED
        if (!mName.empty())
            ILOG_ERROR("Load keyframes via repository");
#endif // REPOSITORY_USED
    }

    // inquiry part

    int
    GetNrKeyframes()
    {
        return Size();
    }

    int
    GetVideoId(int keyId)
    {
        return Get1(keyId);
    }

    int
    GetShotId(int keyId)
    {
        return Get2(keyId);
    }

    String
    GetName(int keyId)
    {
        return Get4(keyId);
    }

    bool
    IsRKF(int keyId)
    {
        return Get4(keyId).find("_RKF") != String::npos;
    }

    int
    GetFrameNr(int keyId)
    {
        return Get3(keyId);
    }

    Core::Table::QuidTable*
    MakeRkfTable()
    {
        Core::Table::QuidTable* quids = new Core::Table::QuidTable(0);
        for(int i=0 ; i<GetNrKeyframes() ; ++i)
        {
            if(IsRKF(i))
                quids->Add(GetQuidFrame(i));
        }
        return quids;
    }
    
    Quid
    GetQuidFrame(int keyId)
    {
        return MakeQuidFrame(mVidSet->GetSetId(), GetVideoId(keyId),
                             GetFrameNr(keyId));
    }

    int
    GetFrameId(Quid quid)
    {
        if (QuidClass(quid) == QUID_CLASS_FRAME)
        {
            int vidId = QuidObject(quid);
            int frame = QuidId(quid);
            return GetFrameIdVideo(vidId, frame);
        }
        ILOG_ERROR("GetFrameId: Unknown quid : " << QuidObj(quid));
        return -1;
    }

    int
    GetFrameId(String name)
    {
        int rank = Find(GetColumn4(), name, 0, Size());
        if (rank == Size())
            return -1;
        return rank;
    }

    // frameNr's are not unique, so "segment" start and end are required
    int
    GetFrameId(int frameNr, int idxStart, int idxEnd)
    {
        int rank = Find(GetColumn3(), frameNr, idxStart, idxEnd);
        if (rank == idxEnd)
            return -1;
        return rank;
    }

    void
    RemoveDuplicates()
    {
        int i=0;
        while (i < Size()-1)
        {
            int j = i+1;
            while ((Get1(i) == Get1(j)) && (Get2(i) == Get2(j))) // same shot?
            {
                if (Get3(i) == Get3(j)) // same frame number?
                {
                    if (Get4(i).find("_RKF") != String::npos)
                    {
                        Core::Table::RemoveRow(this, j);
                    }
                    else
                    {
                        Core::Table::RemoveRow(this, i);
                        j = i+1;
                    }
                }
                else
                {
                    j++;
                }
            }
            i++;
        }
        UpdateGroups();
    }

    VideoSet*
    GetVideoSet()
    {
        return mVidSet;
    }

    // video and shot groups

    void
    UpdateGroups()
    {
        if (mVideoGroups == 0)
        {
            mVideoGroups = new GroupIndex(0);
            mVideoGroups->SetColName(1, "firstKeyframeId");
            mVideoGroups->SetColName(2, "nrKeyframes");
        }
        MakeGroupIndex(mVideoGroups, GetColumn1(), 0, Size());
        if (mShotGroups == 0)
        {
            mShotGroups = new GroupIndex(0);
            mShotGroups->SetColName(1, "firstKeyframeId");
            mShotGroups->SetColName(2, "nrKeyframes");
        }
        // todo?: statement below fails in case a video has only 1 shot
        MakeGroupIndex(mShotGroups, GetColumn2(), 0, Size());
    }

    int
    GetNrVideos()
    {
        return mVideoGroups->Size();
    }

    int
    GetFirstKeyframeVideo(int videoId)
    {
        return mVideoGroups->Get1(videoId);
    }

    int
    GetNrKeyframesVideo(int videoId)
    {
        return mVideoGroups->Get2(videoId);
    }

    int
    GetFrameIdVideo(int videoId, int frameNr)
    {
        int start = GetFirstKeyframeVideo(videoId);
        int nr = GetNrKeyframesVideo(videoId);
        return GetFrameId(frameNr, start, start+nr);
    }

    int
    GetNrShots()
    {
        return mShotGroups->Size();
    }

    int
    GetFirstKeyframeShot(int shotId)
    {
        return mShotGroups->Get1(shotId);
    }

    int
    GetNrKeyframesShot(int shotId)
    {
        return mShotGroups->Get2(shotId);
    }

    int
    GetShotRKF(int shotId)
    {
        int start = GetFirstKeyframeShot(shotId);
        int end = start + GetNrKeyframesShot(shotId);
        for (int i=start ; i<end ; i++)
            if (IsRKF(i))
                return i;
        return start;
    }

    // misc

    int
    Diff(Keyframes* arg)
    {
        if (GetNrKeyframes() != arg->GetNrKeyframes())
        {
            ILOG_ERROR("Diff: nrKeyframes differs: " << GetNrKeyframes() <<
                       " vs " << arg->GetNrKeyframes());
            return 1;
        }
        int nDiff = 0;
        for (int i=0 ; i<GetNrKeyframes() ; i++)
        {
            if (GetVideoId(i) != arg->GetVideoId(i))
            {
                ILOG_DEBUG("Id " << i << " differs " << GetVideoId(i) <<
                           " vs " << arg->GetVideoId(i));
                nDiff++;
            }
            else if (GetShotId(i) != arg->GetShotId(i))
            {
                ILOG_DEBUG("ShotId " << i << " differs " << GetShotId(i) <<
                           " vs " << arg->GetShotId(i));
                nDiff++;
            }
            else if (GetFrameNr(i) != arg->GetFrameNr(i))
            {
                ILOG_DEBUG("FrameNr " << i << " differs " << GetFrameNr(i) <<
                           " vs " << arg->GetFrameNr(i));
                nDiff++;
            }
            else if (GetName(i) != arg->GetName(i))
            {
                ILOG_DEBUG("Name " << i << " differs " << GetName(i) <<
                           " vs " << arg->GetName(i));
                nDiff++;
            }
        }
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences");
        return nDiff;
    }

    // I/O part

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    void
    Load()
    {
        String fName = mVidSet->GetFilePathVideoIndex("", mName + ".tab",
                                                      false, false);
        Read(this, fName, mVidSet->GetDatabase());
        UpdateGroups();
    }

    void
    Save(String name, bool binary)
    {
        if (!name.empty())
            mName = name;
        String fName = mVidSet->GetFilePathVideoIndex("", mName + ".tab",
                                                      true, false);
        Write(this, fName, mVidSet->GetDatabase(), binary);
    }

    void
    Update(String name)
    {
        if (!name.empty())
            mName = name;
        String fName = mVidSet->GetFilePathVideoIndex("", mName + ".tab",
                                                      true, true);
        if (fName.empty())  // try force override thru read
            fName = mVidSet->GetFilePathVideoIndex("", mName + ".tab",
                                                   false, false);
        Write(this, fName, mVidSet->GetDatabase(), true);
    }
#endif // REPOSITORY_USED

    void
    WriteImageSets(bool writeIsUpdate = false)
    {
        UpdateGroups();
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        ImageSet::ImageSet keySet(mVidSet->GetDatabase(), "keyframes.txt", false);
        ImageSet::ImageSet thumbSet(mVidSet->GetDatabase(), "thumbnails.txt", false);
#else // REPOSITORY_USED
        ImageSet::ImageSet keySet("keyframes.txt");
        ImageSet::ImageSet thumbSet("thumbnails.txt");
#endif // REPOSITORY_USED
        for (int s=0 ; s<GetNrShots() ; s++)
        {
            int start = GetFirstKeyframeShot(s);
            int end = start + GetNrKeyframesShot(s);

            //int vid = Get1(start);
            int vid = Get1(start) - Get1(0); // assume id's are contiguous
            String vidName = mVidSet->GetFile(vid);
            String vidSec = mVidSet->GetSectionOfFile(vid);
            String vidDir = mVidSet->GetDirOfFile(vid);

            String keySec = "keyframes/";
            if (Link::DiskImage::DiskImageUsed())
            {
                String videoPath = mVidSet->GetAsPath(vid);
                int posSep = videoPath.find_last_of('/');
                keySec += videoPath.substr(0, posSep);
            }
            else
            {
                keySec += vidSec + "/" + vidDir;
            }

            String thumbSec = StringReplace(keySec, "keyframes", "thumbnails");
            for (int k=start ; k<end ; k++)
            {
                keySet.AddFile(Get4(k), keySec, vidName);
                thumbSet.AddFile(Get4(k), thumbSec, vidName);
            }
        }
        if (writeIsUpdate)
        {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            keySet.UpdateImageSet();
            thumbSet.UpdateImageSet();
#else // REPOSITORY_USED
            ILOG_ERROR("WriteImageSets: Update not implemented yet");
#endif // REPOSITORY_USED
        }
        else
        {
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            keySet.SaveImageSet();
            thumbSet.SaveImageSet();
#else // REPOSITORY_USED
            Persistency::ImageSetLocator keyLoc(mVidSet->GetLocator(),
                                                "keyframes.txt");
            Persistency::ImageSetRepository().Add(keyLoc, &keySet);
            Persistency::ImageSetLocator thumbLoc(mVidSet->GetLocator(),
                                                  "thumbnails.txt");
            Persistency::ImageSetRepository().Add(thumbLoc, &thumbSet);
#endif // REPOSITORY_USED
        }
    }

    void
    DumpGroups()
    {
        mVideoGroups->Dump();
        mShotGroups->Dump();
    }

private:

    VideoSet*   mVidSet;
    String      mName;
    GroupIndex* mVideoGroups;
    GroupIndex* mShotGroups;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(Keyframes, Impala.Core.VideoSet);

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

#endif

---