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

---

TimeLineViewStrip.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Show video frames as a strip on a WindowTimeLine.
//
// Author: Richard van Balen

#ifndef Impala_Visualization_TimeLineViewStrip_h
#define Impala_Visualization_TimeLineViewStrip_h

#ifndef OglGui_WindowTimeLine_h
#include "OglGui/WindowTimeLine.h"
#endif

#ifdef REPOSITORY_USED
//#include "Basis/CmdOptions.h"
#include "Core/Stream/RgbDataSrcFactory.h" // dies as first include with VC8??
#endif

#include "OglGui/FramesPerSecond.h"
#include "Core/Array/Arrays.h"
#include "Core/Stream/RgbDataSrcRaw.h"
#include "Visualization/RgbOglImage.h"

namespace Impala {
namespace Visualization {

class TimeLineViewStrip :  public OglGui::WindowTimeLine
{
public:
    typedef OglGui::Window                  Window;
    typedef OglGui::WindowTimeLine          WindowTimeLine;
    typedef Core::Stream::RgbDataSrc        RgbDataSrc;
    typedef Core::Stream::RgbDataSrcRaw     RgbDataSrcRaw;
#ifdef REPOSITORY_USED
    typedef Core::Stream::RgbDataSrcFactory RgbDataSrcFactory;
#endif
    typedef Core::Array::Array2dVec3UInt8   Array2dVec3UInt8;

    TimeLineViewStrip(int x, int y, int w, int h, int nViews) :
        WindowTimeLine(x,y,w,h)
    {
        Init(w,h,nViews);
    }

    TimeLineViewStrip(Window* parent, int w, int h, int nViews) :
        WindowTimeLine(parent,w,h)
    {
        Init(w,h,nViews);
    }

    TimeLineViewStrip(Window* parent, int x, int y, int w, int h, int nViews) :
        WindowTimeLine(parent,x,y,w,h)
    {
        Init(w,h,nViews);
    }

    void FrameError(int off)              { mFrameError = off; }
    int  FrameError()                     { return mFrameError; }

    void ViewStripFrameStep(int step)     { mViewFrameStep = step; }
    int  ViewStripFrameStep()             { return mViewFrameStep; }
    void ViewStripMinViewWidth(int w)     { mMinViewW = w; }
    int  ViewStripMinViewWidth()          { return mMinViewW; }
    void ViewStripY(int y)                { mViewStripY = y; }
    int  ViewStripY()                     { return mViewStripY; }
    void CurrentViewOnTop(int mode)       { mCurrentViewOnTop = mode % 3; }
    int  CurrentViewOnTop()               { return mCurrentViewOnTop; }
    RgbDataSrc* ViewStripRgbSrc()         { return mRgbDataSrc; }

    void ViewStripShow(bool m)
    {
        if (!(mShow = m))
            ViewStripClearViews();
    }
    bool ViewStripShow()
    {
        return mShow;
    }

    void ViewStripZoomToShowViews(int mode=1)
    {
        int curPix     = Unit2Pixel(mCurrent);
        int nrOfFrames = mRgbDataSrc->LastFrame();
        int docX       = DocX();
        if (mode==0 || mode==1)
            DocW((nrOfFrames*(mMinViewW+(mode?0:-1)))/mViewFrameStep);
        if (mode==2)
            DocW(mMaxDocWidth);
        DocX(docX+(curPix-Unit2Pixel(mCurrent)));
    }

    void ViewStripRgbDataSrc(RgbDataSrc* src)
    {
        if (mRgbDataSrc)
            delete mRgbDataSrc;
        if (!(mRgbDataSrc = src))
        {
            ViewStripClearViews();
            return;
        }

        mImW = mRgbDataSrc->FrameWidth();
        mImH = mRgbDataSrc->FrameHeight();
        int nrFrames = mRgbDataSrc->LastFrame();
        SetSpan(nrFrames * 40);
        SetMinMaxDocWidth(200, nrFrames * mImW);
    }

    bool ViewStripOpenRawFile(std::string fName, bool useMemory=false)
    {
        if (!FileExists(fName))
        {
            ILOG_ERROR("Reading: [" + fName + "] !! does not exist");
            return false;
        }
        if (mRgbDataSrc)
            delete mRgbDataSrc;
        mRgbDataSrc = 0;

#ifndef REPOSITORY_USED
        RgbDataSrcRaw* src = new RgbDataSrcRaw(fName,useMemory);
#else
        CmdOptions& options = CmdOptions::GetInstance();
        String typeStr = options.GetString("TimeLineViewStripRgbSrc");
        if (typeStr.empty())
            typeStr = "raw";
        Persistency::RgbDataSrcLocator loc("dot", fName, options);
        RgbDataSrcFactory& factory = RgbDataSrcFactory::Instance();
        RgbDataSrc* src = factory.Construct(loc, typeStr);
#endif
        if (!src->Valid())
        {
            ILOG_ERROR("Reading [" + fName + "] failed");
            delete src;
            return false;
        }
        ViewStripRgbDataSrc(src);
        return true;
    }

    int FirstVisibleFrame()
    {
        int startFrame = Pixel2Unit(0) / 40;
        if (startFrame < 0)
            startFrame = 0;
        return startFrame;
    }

    int LastVisibleFrame()
    {
        int endFrame   = Pixel2Unit(W()) / 40 + 1;
        int lastSpanFrame = mSpan/40;
        int lastFrame  = mRgbDataSrc ? mRgbDataSrc->LastFrame() : lastSpanFrame;
        if (endFrame > lastFrame)
            endFrame = lastFrame;
        if (endFrame > lastSpanFrame)
            endFrame = lastSpanFrame;
        return endFrame;
    }

    int ViewStripFindIndex(int frameNr, int start=0)
    {
        if (start<0)
            start = 0;
        for (int i=start; i<mViewers.size(); i++)
        {
            if (frameNr == (long long) mViewers[i]->UserData1)
                return i;
        }
        return -1;
    }

    int ViewStripFindIndexBwd(int frameNr, int start=10000)
    {
        if (start > mViewers.size()-1)
            start = mViewers.size()-1;
        for (int i=start; i>=0; i--)
        {
            if (frameNr == (long long) mViewers[i]->UserData1)
                return i;
        }
        return -1;
    }

    void ViewStripClearView(int i)
    {
        if (i<0 || i>=mViewers.size())
            return;
        viewSys.SetImage(mViewers[i], 0);
        viewSys.ClearTags(mViewers[i], visibleTag);
        mViewers[i]->UserData1 = (void*)-1;
    }

    void ViewStripClearViews(int start=0, int end=10000)
    {
        if (start < 0)
            start = 0;
        if (end >= mViewers.size())
            end = mViewers.size();

        for (int i=start; i<end; i++)
            ViewStripClearView(i);
    }

     void ViewStripCopyImageFromView(int dstIdx, int srcIdx, int frameNr)
     {
        viewSys.SetImage(mViewers[dstIdx], mViewers[srcIdx]->im);
        mViewers[dstIdx]->UserData1 = (void *) frameNr;
     }

     void ViewStripCreateImage(int dstIdx, int frameNr)
    {
//printf("Creating %d frNr %d\n", dstIdx, frameNr);
        int imW = mRgbDataSrc->FrameWidth();
        int imH = mRgbDataSrc->FrameHeight();
            Array2dVec3UInt8* ar =
            new Array2dVec3UInt8(imW, imH, 0, 0, 0, false);
        mRgbDataSrc->GotoFrame(frameNr);
            memcpy( (void *) ar->CPB(0, 0), mRgbDataSrc->DataPtr(), imW*imH*3 );
        OGLIMAGE* oglIm = RgbOglImage::OglImage(ar);
        viewSys.SetImage(mViewers[dstIdx],oglIm);
        mViewers[dstIdx]->UserData1 = (void *) frameNr;
        ReleaseOglImage(oglIm);
    }

    bool ViewStripNewPositionNeedsIm(int idx, int frameNr, int space)
    {
        int err = mBothMpg ? 0 : mFrameError;
        int x = Unit2Pixel((frameNr-err)*40);
        int w = (space+1) > mImW ? mImW : space+1; 
        viewSys.SetDimensions(mViewers[idx], x-w/2, mViewStripY, w, mImH);
        viewSys.SetTags(mViewers[idx], visibleTag);
        return ((long long) mViewers[idx]->UserData1) != frameNr;
    }

    void ShowCurrentViewOnTop()
    {
        int v = mViewers.size()-1;
        int f = Current()/40;
        int idx;
        if (ViewStripNewPositionNeedsIm(v, f, mImW))
        {
            if ((idx = ViewStripFindIndex(f,0))!=-1)
                ViewStripCopyImageFromView(v,idx,f);
            else
                ViewStripCreateImage(v,f);
        }
    }

    virtual void InitDisplayFunc()
    {
        WindowTimeLine::InitDisplayFunc();
        if (!mShow || !mRgbDataSrc)
            return;

        int space = Unit2Pixel(mViewFrameStep*40)-Unit2Pixel(0);
        if (space < mMinViewW && mOldSpace >= mMinViewW)
            ViewStripClearViews(0, mViewers.size());

        if ((mOldSpace = space) < mMinViewW)
        {
            if (mCurrentViewOnTop==2)
                ShowCurrentViewOnTop();
            else
                ViewStripClearView(mViewers.size()-1);
            mOldStartFrame = -1;
            return;
        }

        int err = mBothMpg ? 1 : mFrameError;

        int startFrame = FirstVisibleFrame()+err-mViewFrameStep;
        if (startFrame < 0)
            startFrame = 0;
        int endFrame   = LastVisibleFrame()+err+mViewFrameStep;
        if (endFrame > mRgbDataSrc->LastFrame())
            endFrame   = mRgbDataSrc->LastFrame();
        int range      = endFrame-startFrame-1;

        if (range/mViewFrameStep >= mViewers.size())
            range = (mViewers.size()*mViewFrameStep)-1;

        int i, idx, frameNr, vCnt;
        if (mOldStartFrame <= startFrame)
        {
            for (i=0, vCnt=-1; i <= range; i++)
            {
                if ((frameNr = i+startFrame) % mViewFrameStep)
                    continue;
                if (!ViewStripNewPositionNeedsIm(++vCnt, frameNr, space))
                    continue;
                if ((idx = ViewStripFindIndex(frameNr,vCnt))!=-1)
                    ViewStripCopyImageFromView(vCnt,idx,frameNr);
                else
                    ViewStripCreateImage(vCnt,frameNr);
            }
            ViewStripClearViews(vCnt+1, mViewers.size());
        }
        else
        {
            for (vCnt=0,i=range; i>=0; i--)
                if (!((i+startFrame) % mViewFrameStep))
                    vCnt++;
            if (!vCnt) return;
            int lastV = vCnt;
            for (i=range; i>=0; i--)
            {
                if ((frameNr = i+startFrame) % mViewFrameStep)
                    continue;
                if (!ViewStripNewPositionNeedsIm(--vCnt, frameNr, space))
                    continue;
                if ((idx = ViewStripFindIndexBwd(frameNr,vCnt))!=-1)
                    ViewStripCopyImageFromView(vCnt,idx,frameNr);
                else
                    ViewStripCreateImage(vCnt,frameNr);
            }
            ViewStripClearViews(lastV, mViewers.size());
        }

        if (mCurrentViewOnTop)
            ShowCurrentViewOnTop();

        mOldStartFrame = startFrame;
    }

    virtual void KeyboardFunc(int c, int state)
    {
        WindowTimeLine::KeyboardFunc(c,state);
        if (c=='v')
            mCurrentViewOnTop = (mCurrentViewOnTop+1) % 3;
    }

    bool                        mBothMpg;

protected:
    int                         mFrameError;

private:

    void Init(int w, int h, int nViews)
    {
        mRgbDataSrc = 0;
        for (int i=0; i<nViews; i++)
        {
            OGLVIEW* view = viewSys.View2D(mOglWnd,0,0,0,176,144);
            viewSys.SetTags(view, FlexViewTags);
            viewSys.ClearTags(view, visibleTag|showBorderTag|selectableTag);
            view->UserData1 = (void *) -1;
            mViewers.push_back(view);
            mBothMpg = false;
        }
        mOldSpace = 0;
        mOldStartFrame = -1;
        mMinViewW = 6;
        mViewFrameStep = 1;
        mViewStripY = 24;
        mFrameError = 0;
        mShow = true;
        mCurrentViewOnTop = 0;
    }

    RgbDataSrc*                 mRgbDataSrc;
    std::vector<OGLVIEW*>       mViewers;

    bool                        mShow;
    int                         mCurrentViewOnTop; // 0=No, 1=when space, 2=always

    int                         mViewStripY;
    int                         mOldSpace;
    int                         mOldStartFrame;

    int                         mViewFrameStep;
    int                         mMinViewW;

    int                         mImW;
    int                         mImH;

    bool                        mPlaying;
    int                         mIncr;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(TimeLineViewStrip, Visualization);

} // namespace Visualization
} // namespace Impala
#endif

---