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

---

Segmentation.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_Segmentation_h
#define Impala_Core_VideoSet_Segmentation_h

#include "Core/Table/MakeGroupIndex.h"
#include "Core/VideoSet/VideoSet.h"
#include "Core/Table/TableTem.h"
#include "Core/Table/Read.h"
#include "Core/Table/Write.h"
#include "Core/Column/Find.h"
#include "Core/Column/Contains.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


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


class Segmentation : public SegmentationBaseType
{
    typedef Impala::Core::Table::GroupIndex GroupIndex;

public:

    Segmentation(VideoSet* vidSet, String name) : SegmentationBaseType(0)
    {
        mVidSet = vidSet;
        mName = name;
        mVideoGroups = 0;
        SetColName(1, "videoId");
        SetColName(2, "startFrame");
        SetColName(3, "endFrame");
        SetColName(4, "name");
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
        if (!mName.empty())
            Load();
#else // REPOSITORY_USED
        if (!mName.empty())
            ILOG_ERROR("Load segmentation via repository");
#endif // REPOSITORY_USED
    }

    // inquiry part

    int
    GetNrShots()
    {
        return Size();
    }

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

    int
    GetStart(int shotId)
    {
        return Get2(shotId);
    }

    int
    GetEnd(int shotId)
    {
        return Get3(shotId);
    }

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

    Quid
    GetQuidShot(int shotId)
    {
        int vidId = GetVideoId(shotId);
        return MakeQuidShot(mVidSet->GetSetId(), vidId,
                            shotId - GetFirstShotVideo(vidId));
    }

    Quid
    GetQuidShot(int videoId, int frameNr)
    {
        int shotId = GetShotId(videoId, frameNr);
        if (shotId == Size())
            return 0;
        if (shotId == -1)
            return 0;
        return GetQuidShot(shotId);
    }

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

    int
    GetShotId(int videoId, int frameNr)
    {
        int first = GetFirstShotVideo(videoId);
        int number = GetNrShotsVideo(videoId);
        for (int s=first ; s<first+number ; s++)
            if ((frameNr >= GetStart(s)) && (frameNr <= GetEnd(s)))
                return s;
        return -1;
    }

    int
    GetShotId(Quid quid)
    {
        if (QuidClass(quid) == QUID_CLASS_SHOT)
        {
            int vidId = QuidObject(quid);
            int shot = QuidId(quid);
            return GetFirstShotVideo(vidId) + shot;
        }
        if (QuidClass(quid) == QUID_CLASS_FRAME)
        {
            int vidId = QuidObject(quid);
            int frame = QuidId(quid);
            return GetShotId(vidId, frame);
        }
        ILOG_ERROR("GetShotId: Unknown quid : " << QuidObj(quid));
        return -1;
    }

    std::vector<int>
    GetShotIds(int videoId, int startFrame, int endFrame, int minimalOverlap)
    {
        std::vector<int> res;
        int first = GetShotId(videoId, startFrame);
        int last = GetShotId(videoId, endFrame);
        if ((first == Size()) || (last == Size()))
            return res;

        if (first == last)
        {
            if (endFrame - startFrame + 1 > minimalOverlap)
                res.push_back(first);
            return res;
        }

        if (GetEnd(first) - startFrame + 1 > minimalOverlap) 
            res.push_back(first);
        if (last - first > 1)
        {
            for (int s=first+1 ; s<last ; s++)
                res.push_back(s);
        }
        if (endFrame - GetStart(last) + 1 > minimalOverlap)
            res.push_back(last);
        return res;
    }

    VideoSet*
    GetVideoSet()
    {
        return mVidSet;
    }

    // video group

    void
    UpdateGroups()
    {
        if (mVideoGroups == 0)
            mVideoGroups = new GroupIndex(0);
        MakeGroupIndex(mVideoGroups, GetColumn1(), 0, Size());
    }

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

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

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

    // assumes that the last shot is really the end of the video
    int
    GetNrFramesVideo(int videoId)
    {
        int lastShot = GetFirstShotVideo(videoId) + GetNrShotsVideo(videoId) - 1;
        return GetEnd(lastShot) + 1;
    }

    // assumes that the last shot of each video is really the end of the video
    int
    GetTotalNrFrames()
    {
        int res = 0;
        for (int i=0 ; i<GetNrVideos() ; i++)
            res += GetNrFramesVideo(i);
        return res;
    }

    // misc

    int
    Diff(Segmentation* arg)
    {
        if (GetNrShots() != arg->GetNrShots())
        {
            ILOG_ERROR("Diff: nrShots differs: " << GetNrShots() << " vs " <<
                       arg->GetNrShots());
            return 1;
        }
        int nDiff = 0;
        for (int i=0 ; i<GetNrShots() ; i++)
        {
            if (GetVideoId(i) != arg->GetVideoId(i))
            {
                ILOG_DEBUG("Id " << i << " differs " << GetVideoId(i) <<
                           " vs " << arg->GetVideoId(i));
                nDiff++;
            }
            else if (GetStart(i) != arg->GetStart(i))
            {
                ILOG_DEBUG("Start " << i << " differs " << GetStart(i) <<
                           " vs " << arg->GetStart(i));
                nDiff++;
            }
            else if (GetEnd(i) != arg->GetEnd(i))
            {
                ILOG_DEBUG("End " << i << " differs " << GetEnd(i) <<
                           " vs " << arg->GetEnd(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

private:

    VideoSet*   mVidSet;
    String      mName;
    GroupIndex* mVideoGroups;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(Segmentation, Impala.Core.VideoSet);

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

#endif

---