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

---

SegmentationDocument.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_SegmentationDocument_h
#define Impala_Core_VideoSet_SegmentationDocument_h

#include "Core/Database/DataDocument.h"
#include "Core/VideoSet/TableShots.h"
#include "Core/VideoSet/Segmentation.h"
#include "Core/VideoSet/Keyframes.h"
#include "Core/ImageSet/ImageSet.h"
#include "Core/Table/RemoveRow.h"
#include "Core/Column/Copy.h"
#include "Core/Column/Find.h"
#include "Core/Column/Contains.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class SegmentationDocument : public Database::DataDocument
{
public:
    typedef TableShots BookmarkedType;
    typedef Core::ImageSet::ImageSet ImageSet;

    SegmentationDocument(VideoSet* vidSet, Segmentation* shots,
                         Keyframes* keyframes, ImageSet* imSetKeyfr,
                         ImageSet* imSetThumb, ImageSet* imSetStill) :
        Database::DataDocument(vidSet)
    {
        mVidSet = vidSet;
        mShots = shots;
        mKeyframes = keyframes;
        mImSetKeyfr = imSetKeyfr;
        mImSetThumb = imSetThumb;
        mImSetStill = imSetStill;

        mCurrentKeyfrId = -1;
        mCurrentShotId = -1;
        mCurrentKeyframes = new TableIds(50);

        mBookmarked = new TableShots();
        mBookmarkedIds = new TableIds(0);
    }

    VideoSet*
    GetVideoSet()
    {
        return mVidSet;
    }

    Segmentation*
    GetSegmentation()
    {
        return mShots;
    }

    Keyframes*
    GetKeyframes()
    {
        return mKeyframes;
    }

    ImageSet*
    GetImSetKeyframes(bool thumbnails)
    {
        if (thumbnails)
            return mImSetThumb;
        return mImSetKeyfr;
    }

    ImageSet*
    GetImSetStills()
    {
        return mImSetStill;
    }

    // DataDocument cursor part

    virtual bool
    HasCursor()
    {
        return HasCurShot();
    }

    bool
    GotoPrevVideo()
    {
        return TryVideoMoveCursor(-1);
    }

    bool
    GotoNextVideo()
    {
        return TryVideoMoveCursor(1);
    }

    virtual Database::DocLevel
    CursorToDir(int dirId)
    {
        mCurDirId = dirId;
        return CursorToFile(mVidSet->GetFirstFileId(dirId));
    }

    virtual Database::DocLevel
    CursorPrevFile()
    {
        if (GotoPrevVideo())
            return Database::LEVEL_FILE;
        return Database::LEVEL_NONE;
    }

    virtual Database::DocLevel
    CursorNextFile()
    {
        if (GotoNextVideo())
            return Database::LEVEL_FILE;
        return Database::LEVEL_NONE;
    }


    virtual Database::DocLevel
    CursorToFile(int fileId)
    {
        ILOG_DEBUG("fileId = " << fileId);
        if (TryVideoMove(fileId))
            return Database::LEVEL_FILE;
        return Database::LEVEL_NONE;
    }

    virtual Database::DocLevel
    CursorPrevShot()
    {
        if (GotoPrevShot(1))
            return Database::LEVEL_SHOT;
        return Database::LEVEL_NONE;
    }

    virtual Database::DocLevel
    CursorNextShot()
    {
        if (GotoNextShot(1))
            return Database::LEVEL_SHOT;
        return Database::LEVEL_NONE;
    }

    Database::DocLevel
    CursorToBookmark(int idx)
    {
        if (mBookmarked->SetCursor(idx))
            return CursorToCurBookmark();
        return Database::LEVEL_NONE;
    }

    Database::DocLevel
    CursorNextBookmark()
    {
        if (mBookmarked->MoveCursor(1))
            return CursorToCurBookmark();
        return Database::LEVEL_NONE;
    }

    Database::DocLevel
    CursorPrevBookmark()
    {
        if (mBookmarked->MoveCursor(-1))
            return CursorToCurBookmark();
        return Database::LEVEL_NONE;
    }

    virtual Database::DocLevel
    CursorToCurBookmark()
    {
        if (!mBookmarked->HasCursor())
            return Database::LEVEL_NONE;
        GotoKeyfr(mBookmarked->Get2AtCursor());
        SetRect(mBookmarked->Get4AtCursor());
        SetConcept(mBookmarked->Get3AtCursor());
        return Database::LEVEL_FILE;
    }

    // ownership resides with caller
    // data only garanteed as long as cursor doesn't move
    virtual Array::Array2dVec3UInt8*
    VisualAtCursor(bool thumbnail)
    {
        if (!HasCursor())
            return 0;
        if (thumbnail && mImSetThumb)
            return mImSetThumb->GetImage(mCurrentKeyfrId);
        if (!thumbnail && mImSetKeyfr)
            return mImSetKeyfr->GetImage(mCurrentKeyfrId);
        return 0;
    }

    bool
    HasCurShot()
    {
        return mCurrentKeyfrId != -1;
    }

    int
    CurShot()
    {
        return mCurrentShotId;
    }

    int
    CurKeyfr()
    {
        return mCurrentKeyfrId;
    }

    TableIds*
    CurKeyframes()
    {
        return mCurrentKeyframes;
    }

    int
    CurFrame()
    {
        if (mCurrentKeyfrId == -1)
            return -1;
        return mKeyframes->GetFrameNr(mCurrentKeyfrId);
    }

    void
    GotoKeyfr(int keyfrId)
    {
        mCurrentKeyfrId = keyfrId;
        ILOG_DEBUG("mCurrentKeyfrId = " << mCurrentKeyfrId);
        mCurrentShotId = -1;
        mCurrentKeyframes->SetEmpty();
        if (mCurrentKeyfrId != -1)
        {
            mCurrentShotId = mKeyframes->GetShotId(mCurrentKeyfrId);
            int nrKey = mKeyframes->GetNrKeyframesShot(mCurrentShotId);
            int firstKey = mKeyframes->GetFirstKeyframeShot(mCurrentShotId);
            for (int i=0 ; i<nrKey ; i++)
                mCurrentKeyframes->Add(firstKey + i);
        }
        ILOG_DEBUG("mCurrentShotId = " << mCurrentShotId);
        // inform base class
        if (mCurrentShotId == -1)
            GotoFile(-1);
        else
            GotoFile(mShots->GetVideoId(mCurrentShotId));
    }

    bool
    GotoShotKeyfr(int idx) // idx is index in keyframes current shot
    {
        if (!HasCurShot())
            return false;
        mCurrentKeyfrId = mCurrentKeyframes->Get1(idx);
        GotoFile(mShots->GetVideoId(mCurrentShotId)); // inform base class
        return true;
    }

    void
    GotoShot(int shot)
    {
        GotoKeyfr(mKeyframes->GetFirstKeyframeShot(shot));
    }

    bool
    GotoPrevShot(int steps = 1, bool withinVideo = true)
    {
        return TryShotMove(mCurrentShotId - steps, withinVideo);
    }

    bool
    GotoNextShot(int steps = 1, bool withinVideo = true)
    {
        return TryShotMove(mCurrentShotId + steps, withinVideo);
    }

    // returns id of shot, -1 if not applicable
    int
    GetPrevShot(int steps = 1)
    {
        return GetShotMove(mCurrentShotId, -1, steps);
    }

    // returns id of shot, -1 if not applicable
    int
    GetNextShot(int steps = 1)
    {
        return GetShotMove(mCurrentShotId, 1, steps);
    }

    // bookmarked part

    BookmarkedType*
    GetBookmarked()
    {
        return mBookmarked;
    }

    // return keyframe id's
    TableIds*
    GetBookmarkedIds()
    {
        mBookmarkedIds->ReserveMin(mBookmarked->Size(), false);
        Column::Copy(mBookmarkedIds->GetColumn1(), mBookmarked->GetColumn2(),
                     mBookmarked->Size(), 0, 0);
        mBookmarkedIds->SetSize(mBookmarked->Size());
        return mBookmarkedIds;
    }

    virtual bool
    HasBookmarks()
    {
        return mBookmarked->Size() > 0;
    }

    bool
    HasCurBookmark()
    {
        return mBookmarked->HasCursor();
    }

    int
    CurBookmark()
    {
        return mBookmarked->GetCursor();
    }

    std::string
    CurBookmarkAnno()
    {
        if (!HasCurBookmark())
            return std::string("");
        return mBookmarked->Get3AtCursor();
    }

    virtual std::string
    DescribeBookmark(int idx)
    {
        int shot = mBookmarked->Get1(idx);
        return mShots->GetName(shot) + "  " + mBookmarked->Get3(idx);
    }

    virtual bool
    AddCursorToBookmarked()
    {
        if (! HasCursor())
            return false;
        if (Column::Contains(mBookmarked->GetColumn1(), CurShot(),
                             0, mBookmarked->Size()))
            return false;
        return AddShotToBookmarked(CurShot(), CurKeyfr());
    }

    virtual bool
    RemoveCursorFromBookmarked()
    {
        if (! HasCurBookmark())
            return false;
        int cursor = mBookmarked->GetCursor();
        Table::RemoveRow(mBookmarked, mBookmarked->GetCursor());
        CursorToBookmark(cursor);
        return true;
    }

    virtual void
    ClearBookmarked()
    {
        mBookmarked->SetEmpty();
    }

    virtual void
    LoadBookmarked(std::string fileName)
    {
        mBookmarkedFileName = fileName;
        mBookmarked->ReadVxsFile(fileName, mKeyframes);
    }

    // conceptName is used only when bookmark does not have its own annotation
    virtual void
    SaveBookmarked(std::string fileName, std::string conceptName)
    {
        mBookmarked->WriteVxsFile(fileName, conceptName, mShots, mKeyframes);
    }

    std::string
    GetBookmarkedFileName()
    {
        return mBookmarkedFileName;
    }

    void
    LoadConceptsFromBookmarks()
    {
        for (int i=0 ; i<mBookmarked->Size() ; i++)
            AddConcept(mBookmarked->Get3(i));
    }

    bool
    AddShotToBookmarked(int shot, int keyfr)
    {
        return mBookmarked->Add(shot, keyfr, GetConcept(), GetRect());
    }

    int
    GetKeyOfBookmarked(int idx)
    {
        return mBookmarked->Get2(idx);
    }

    int
    GetKeyOfBookmarkedShot(int shot)
    {
        int bookIdx = Column::Find(mBookmarked->GetColumn1(), shot,
                                      0, mBookmarked->Size());
        if (bookIdx != mBookmarked->Size())
            return GetKeyOfBookmarked(bookIdx);
        return -1;
    }

    // misc

    virtual void
    Clear()
    {
        Database::DataDocument::Clear();
        mBookmarked->SetEmpty();
        GotoKeyfr(-1);
    }

    int
    GetShotRepresentative(int shot)
    {
        if (shot == -1)
            return -1;
        int bookIdx = Column::Find(mBookmarked->GetColumn1(), shot,
                                      0, mBookmarked->Size());
        if (bookIdx != mBookmarked->Size())
            return GetKeyOfBookmarked(bookIdx);
        return mKeyframes->GetShotRKF(shot);
    }

private:

    bool
    TryVideoMoveCursor(int inc)
    {
        if (!HasCursor())
            return false;
        return TryVideoMove(CurFileId() + inc);
    }

    bool
    TryVideoMove(int vid)
    {
        ILOG_DEBUG("vid = " << vid);
        if ((vid < 0) || (vid >= mVidSet->NrFiles()))
            return false;
        int newShot = mShots->GetFirstShotVideo(vid);
        ILOG_DEBUG("newShot = " << newShot);
        GotoKeyfr(GetShotRepresentative(newShot));
        return true;
    }

    bool
    TryShotMove(int newShot, bool withinVideo)
    {
        if ((newShot < 0) || (newShot >= mShots->GetNrShots()))
            return false;
        if (!HasCurShot())
            return false;
        if (withinVideo && (! SameVideo(mCurrentShotId, newShot)))
            return false;
        GotoKeyfr(GetShotRepresentative(newShot));
        return true;
    }

    int
    GetShotMove(int oldShot, int dir, int steps)
    {
        int newShot = oldShot + dir;
        if ((newShot < 0) || (newShot >= mShots->GetNrShots()))
            return -1;
        if (! SameVideo(mCurrentShotId, newShot))
            return -1;
        if (--steps <= 0)
            return newShot;
        return GetShotMove(newShot, dir, steps);
    }

    bool
    SameVideo(int shotId1, int shotId2)
    {
        return mShots->GetVideoId(shotId1) == mShots->GetVideoId(shotId2);
    }

    bool
    SameShot(int keyfrId1, int keyfrId2)
    {
        return mKeyframes->GetShotId(keyfrId1) == mKeyframes->GetShotId(keyfrId2);
    }

    VideoSet*     mVidSet;
    Segmentation* mShots;
    Keyframes*    mKeyframes;
    ImageSet*     mImSetThumb;
    ImageSet*     mImSetKeyfr;
    ImageSet*     mImSetStill;

    int       mCurrentShotId;    // current shot
    int       mCurrentKeyfrId;   // selected keyframe in current shot
    TableIds* mCurrentKeyframes; // keyframes in the current shot

    TableShots* mBookmarked;
    TableIds*   mBookmarkedIds;
    std::string mBookmarkedFileName; // filename of last loaded

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(SegmentationDocument, Impala.Core.VideoSet);

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

#endif

---