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

---

VxsDocument.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_VxsDocument_h
#define Impala_Core_VideoSet_VxsDocument_h

#include "Core/Database/DataDocument.h"
#include "Core/Table/TableVxs.h"
#include "Core/Table/RemoveRow.h"
#include "Core/VideoSet/VideoSet.h"
#include "Core/Column/Copy.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class VxsDocument : public Database::DataDocument
{
public:
    typedef Core::Table::TableVxs TableVxs;
    typedef TableVxs BookmarkedType;

    VxsDocument(VideoSet* vidSet) : Database::DataDocument(vidSet)
    {
        mVidSet = vidSet;
        mCurSrc = 0;
        mCurSrcId = -1;
        mMarkedFrameBegin = -1;
        mMarkedFrameEnd = -1;
        mStepSize = 1;
        mCurrentFrame = -1;
        mBookmarked = new TableVxs();
        mBookmarkedIds = new TableIds(0);
    }

    VideoSet*
    GetVideoSet()
    {
        return mVidSet;
    }

    // DataDocument cursor part

    virtual bool
    HasCursor()
    {
        return mCurrentFrame != -1;
    }

    Stream::RgbDataSrc*
    CurVideo()
    {
        return mCurSrc;
    }

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

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

    bool
    GotoPrevFrame(int steps = 1)
    {
        return TryFrameMove(-steps);
    }

    bool
    GotoNextFrame(int steps = 1)
    {
        return TryFrameMove(steps);
    }

    int
    GetMarkedFrameBegin()
    {
        return mMarkedFrameBegin;
    }

    void
    SetMarkedFrameBegin(int frameNr)
    {
        mMarkedFrameBegin = frameNr;
    }

    int
    GetMarkedFrameEnd()
    {
        return mMarkedFrameEnd;
    }

    void
    SetMarkedFrameEnd(int frameNr)
    {
        mMarkedFrameEnd = frameNr;
    }

    int
    GetStepSize()
    {
        return mStepSize;
    }

    void
    SetStepSize(int stepSize)
    {
        mStepSize = stepSize;
    }

    virtual Database::DocLevel
    CursorToDir(int dirId)
    {
        return CursorToFile(dirId);
    }

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

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

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

    virtual Database::DocLevel
    CursorLeft()
    {
        if (GotoPrevFrame(mStepSize))
            return Database::LEVEL_FRAME;
        return Database::LEVEL_NONE;
    }

    virtual Database::DocLevel
    CursorRight()
    {
        if (GotoNextFrame(mStepSize))
            return Database::LEVEL_FRAME;
        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;

        int startF = mBookmarked->Get1AtCursor();
        int endF = mBookmarked->Get2AtCursor();
        GotoFrame(mBookmarked->Get9AtCursor(), startF);

        SetMarkedFrameBegin(startF);
        SetMarkedFrameEnd(endF);
        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 (!mCurSrc)
            return 0;
        Array::Array2dVec3UInt8* srcWrap = Array::ArrayCreate<Array::Array2dVec3UInt8>
            (mCurSrc->FrameWidth(), mCurSrc->FrameHeight(), 0, 0,
             mCurSrc->DataPtr(), true);
        // todo : scale when thumbnail
        return srcWrap;
    }

    void
    SetFrameNavBetweenMarked(bool flag)
    {
        mFrameNavBetweenMarked = flag;
    }

    bool
    HasCurFrame()
    {
        return mCurrentFrame != -1;
    }

    int
    CurFrame()
    {
        return mCurrentFrame;
    }

    void
    GotoFrame(int vid, int frame)
    {
        if (vid == mCurSrcId)
        {
            GotoFrame(frame);
            return;
        }
        if (mCurSrc)
            delete mCurSrc;
        mCurSrc = 0;
        mCurSrcId = vid;
        GotoFile(mCurSrcId);
        mCurSrc = mVidSet->GetVideo(mCurSrcId);
        mMarkedFrameBegin = -1;
        mMarkedFrameEnd = -1;
        GotoFrame(frame);
    }

    void
    GotoFrame(int frame)
    {
        if (frame == -1)
        {
            mCurrentFrame = -1;
            return;
        }
        if (mCurSrc)
        {
            mCurSrc->GotoFrame(frame);
            int nStartRetry = 3;
            while ((nStartRetry > 0) && (mCurSrc->DataPtr() == 0))
            {
                std::cout << "Skipping empty frame" << std::endl;
                nStartRetry--;
                mCurSrc->NextFrame();
            }
            mCurrentFrame = mCurSrc->FrameNr();
        }
    }

    // bookmarked part

    BookmarkedType*
    GetBookmarked()
    {
        return mBookmarked;
    }

    TableIds*
    GetBookmarkedIds()
    {
        mBookmarkedIds->ReserveMin(mBookmarked->Size(), false);
        Column::Copy(mBookmarkedIds->GetColumn1(), mBookmarked->GetColumn9(),
                     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 fileId = mBookmarked->Get9(idx);
        return mDataSet->GetFile(fileId) + "  " + mBookmarked->Get3(idx) + "  ("
            + mDataSet->GetSectionOfFile(fileId)
            + "/" + mDataSet->GetDirOfFile(fileId) + ")";
    }

    int
    TotalNrFramesInBookmarked()
    {
        int nr = 0;
        for (int i=0 ; i<mBookmarked->Size() ; i++)
        {
            nr += mBookmarked->Get2(i) - mBookmarked->Get1(i) + 1;
        }
        return nr;
    }

    virtual bool
    AddCursorToBookmarked()
    {
        if (! HasCursor())
            return false;
        if ((mMarkedFrameBegin == -1) || (mMarkedFrameEnd == -1))
            return AddSegmentToBookmarked(CurFileId(), mCurrentFrame,
                                          mCurrentFrame);
        return AddSegmentToBookmarked(CurFileId(), mMarkedFrameBegin,
                                      mMarkedFrameEnd);
    }

    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);
        Database::RawDataSet* dataSet = GetDataSet();
        for (int i=0 ; i<mBookmarked->Size() ; i++)
        {
            int fileId = dataSet->GetFileId(mBookmarked->Get6(i),
                                            mBookmarked->Get7(i),
                                            mBookmarked->Get5(i));
            mBookmarked->GetColumn9()->Set(i, fileId);
        }
        /* todo done?
        std::vector<CxVxRectZ> vrList;
        CxFxReadVxRectZ(std::back_inserter(vrList), fileName);
        for (int i=0 ; i<vrList.size() ; i++)
        {
            int id;
            if (HasShots())
            {
                CxString shotName = vrList[i].mExtra;
                int shotId = mShots->GetSegmentId(shotName);
                int startIdx = mShots->GetFirstKeyframeId(shotId);
                int endIdx = startIdx + mShots->GetNrKeyframes(shotId);
                int frameNr = vrList[i].mStartFrame;
                int frameId = mKeyframes->GetFrameId(frameNr, startIdx, endIdx);
                vrList[i].mExtra = CxMakeString(frameId);
                id = shotId;
            }
            else
            {
                id = vrList[i].mStartFrame;
            }
            mBookmarked->AddIdWithAny(id, vrList[i]);
        }
        */
    }

    // conceptName is used only when bookmark does not have its own annotation
    virtual void
    SaveBookmarked(std::string fileName, std::string conceptName)
    {
        /* todo
        std::vector<CxVxRectZ> vrList;
        for (int i=0 ; i<mBookmarked->NrFilled() ; i++)
        {
            CxVxRectZ vr = mBookmarked->GetAny(i);
            if (vr.mAnno == std::string(""))
                vr.mAnno = conceptName;
            if (HasShots())
                vr.mExtra = mShots->GetName(i);
            vrList.push_back(vr);
        }
        CxFxWriteVxRectZ(fileName, vrList.begin(), vrList.end());
        */
    }

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

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

    bool
    AddSegmentToBookmarked(int vid, int startFrame, int endFrame)
    {
        /* todo
        CxVxRectZ vr;
        vr.mVideoName = mVidSet->GetFile(vid);
        vr.mSection = mVidSet->GetSectionOfFile(vid);
        vr.mDir = mVidSet->GetDirOfFile(vid);
        vr.mStartFrame = startFrame;
        vr.mEndFrame = endFrame;
        vr.mRect = GetRect();
        vr.mAnno = GetConcept();
        if (mBookmarked->AddIdWithAny(startFrame, vr))
            return true;
        */
        return false;
    }

    // misc

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

private:

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

    bool
    TryVideoMove(int vid)
    {
        if ((vid < 0) || (vid >= mVidSet->NrFiles()))
            return false;
        GotoFrame(vid, 0);
        return true;
    }

    bool
    TryFrameMove(int inc)
    {
        if (mCurSrc)
        {
            int newFrame = mCurSrc->FrameNr() + inc;
            if ((newFrame < 0) || (newFrame > mCurSrc->LastFrame()))
                return false;
            if (mFrameNavBetweenMarked && (mMarkedFrameBegin != -1)
                && (newFrame < mMarkedFrameBegin))
                return false;
            if (mFrameNavBetweenMarked && (mMarkedFrameEnd != -1)
                && (newFrame > mMarkedFrameEnd))
                return false;
            mCurSrc->NextFrame(inc);
            mCurrentFrame = mCurSrc->FrameNr();
            return true;
        }
        return false;
    }

    VideoSet*   mVidSet;
    Stream::RgbDataSrc* mCurSrc;
    int         mCurSrcId;
    int         mCurrentFrame;
    int         mMarkedFrameBegin;
    int         mMarkedFrameEnd;
    int         mStepSize; // number of steps in cursor left/right
    bool        mFrameNavBetweenMarked; // keep frame nav between marked frames

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

};

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

#endif

---