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

---

DirImViewer.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_DirImViewer_h
#define Impala_Visualization_DirImViewer_h

#include <time.h>

#include "OglGui/FramesPerSecond.h"
#include "OglGui/DocDimensions.h"
#include "OglGui/DocFlowDrag.h"
#include "Util/DirImageFileNames.h"
#include "Core/Array/ReadFile.h"
#include "Visualization/RgbOglImage.h"

#ifndef NO_RAW
#include "Core/Stream/RgbDataSrcFactory.h"
#endif

namespace Impala {
namespace Visualization {

class DirImViewer :  public OglGui::Window,
                     public OglGui::DocDimensions
{
public:
    typedef OglGui::Window                  Window;
    typedef Core::Array::Array2dVec3UInt8   Array2dVec3UInt8;
#ifndef NO_RAW
    typedef Core::Stream::RgbDataSrcFactory RgbDataSrcFactory;
    typedef Core::Stream::RgbDataSrc        RgbDataSrc;
#endif

    DirImViewer(int x, int y, int w, int h, int nOnRow=4) :
        Window(x,y,w,h)
    {
        Init(w,h,nOnRow);
    }

    DirImViewer(Window* parent, int w, int h, int nOnRow=4) :
        Window(parent,w,h)
    {
        Init(w,h,nOnRow);
    }

    DirImViewer(Window* parent, int x, int y, int w, int h, int nOnRow=4) :
        Window(parent,x,y,w,h)
    {
        Init(w,h,nOnRow);
    }

    ~DirImViewer()
    {
        ClearFiles();
    }

    void OpenDir(strconst dirName)
    {
        ClearFiles();
        mDirName = dirName;
        String fExt = FileNameExt(dirName);
#ifndef NO_RAW
        if ((fExt == "raw") || (fExt == "mpg") || (fExt == "mpeg"))
        {
 #ifdef REPOSITORY_USED
            OpenSrc(Persistency::RgbDataSrcLocator("file:", "abs", dirName));
 #else
            RgbDataSrcFactory& f = RgbDataSrcFactory::Instance();
            mRgbDataSrc = f.Construct(dirName, fExt);
 #endif //REPOSITORY_USED
        }
#endif // NO_RAW
        Util::DirImageFileNames(dirName, mFileNames);
        HandleDocDimensions(true,true);
    }

#if !defined(NO_RAW) && defined(REPOSITORY_USED)
    void OpenSrc(const Persistency::RgbDataSrcLocator& loc)
    {
        ClearFiles();
        mDirName = loc.GetName();
        RgbDataSrcFactory& f = RgbDataSrcFactory::Instance();
        //mRgbDataSrc = f.Construct(RgbDataSrcFactory::SRC_RAW, loc);
        mRgbDataSrc = f.Construct(loc, "");
        HandleDocDimensions(true,true);
    }
#endif

    void NrOfImOnRow(int n)         { mFixedCellDims = !(mNrOfImOnRow = n); }
    int  NrOfImOnRow()              { return mNrOfImOnRow; }
    void ShowNames(bool mode)       { mExtH = (mShowNames = mode) ? 6 : 0; }
    bool ShowNames()                { return mShowNames; }
    void ShowDims(bool mode)        { mShowDims = mode; }
    bool ShowDims()                 { return mShowDims; }
    int  CellWidth()                { return mCellW; }
    int  CellHeight()               { return mCellH; }
    void PagingExtra(int x)         { mPagingExtra = x; }
    int  PagingExtra()              { return mPagingExtra; }

    void MaxZoom(double mz)         { mMaxZoom = mz; }

    int  NrOfFiles()
    {
#ifndef NO_RAW
        if (mRgbDataSrc)
            return mRgbDataSrc->LastFrame();
#endif
        return mFileNames.size();
    }

    void FixedCellWidth(int w)
    {
        if (mFixedCellDims = (w > 20)) 
            mCellH = mExtH + (mCellW = w);
        else
            mCellH = mExtH + (mCellW = 128);
    }

    int ClampImIdx(int& idx)
    {
        if (idx < 0)
            idx = 0;
        if (idx > NrOfFiles()-1)
            idx = NrOfFiles()-1;
        return idx;
    }

    int ClampViewIdx(int& idx)
    {
        if (idx < 0)
            idx = 0;
        if (idx > mViews.size()-1)
            idx = mViews.size()-1;
        return idx;
    }

    void ClearFiles()
    {
#ifndef NO_RAW
        if (mRgbDataSrc)
        {
            delete mRgbDataSrc;
            mRgbDataSrc = 0;
        }
#endif
        unsigned int i;
        for (i=0 ; i<mFileNames.size() ; i++)
            delete mFileNames[i];
        mFileNames.clear();
    }

    void ClearViews(int start=0, int end=10000)
    {
        ClampViewIdx(start);
        ClampViewIdx(end);
        for (int i=start; i<end; i++)
        {
            viewSys.SetImage(mViews[i], 0);
            viewSys.ClearTags(mViews[i], visibleTag);
            mViews[i]->UserData1 = (void*)-1;
        }
    }

    int Y2Row(int y)
    {
        return (mDocY + mDocH - y) / mCellH;
    }
    int Row2Y(int row)
    {
        return (mDocY+mDocH-(row+1)*mCellH);
    }

    int NrRows()
    {
        return NrOfFiles() / mNrOfImOnRow;
    }

    int FindFirstVisible()
    {
        int first = Y2Row(H()) * mNrOfImOnRow;
        return ClampImIdx(first);
    }
    int FindLastVisible()
    {
        int last = Y2Row(-mCellH) * mNrOfImOnRow;
        return ClampImIdx(last);
    }

    int FindIndexFwd(int imIdx, int start=0)
    {
        ClampViewIdx(start);
        for (int i=start; i<mViews.size(); i++)
        {
            if (imIdx == (long long) mViews[i]->UserData1)
                return i;
        }
        return -1;
    }

    int FindIndexBwd(int imIdx, int start=10000)
    {
        ClampViewIdx(start);
        for (int i=start; i>=0; i--)
        {
            if (imIdx == (long long) mViews[i]->UserData1)
                return i;
        }
        return -1;
    }

    int FindIndex(int imIdx, int start, bool backward=false)
    {
        if (backward)
            return FindIndexBwd(imIdx, start);
        else
            return FindIndexFwd(imIdx, start);
    }

    void HandleDocDimensions(bool resizing=false, bool reset=false)
    {
        if (!mFixedCellDims)
        {
            mCellW = W() / mNrOfImOnRow;
            mCellH = mCellW + (mShowNames ? mExtH : 0);
        }
        else if ((mNrOfImOnRow = W() / mCellW)<1)
            mNrOfImOnRow = 1;

        int docH = (NrOfFiles() / mNrOfImOnRow) * mCellH;

        if (resizing && mOldStartIm != -1)
        {
            int row = mOldStartIm / mNrOfImOnRow;
            mDocY = H() - (NrRows() - row) * mCellH;
        }
        if (mDocY < (-docH+H()))
            mDocY = -docH+H();
        if (reset)
            SetDocDimensions(0,-docH+H(),W(), docH);
        else
            SetDocDimensions(mDocX, mDocY, W(), docH);
    }

    void HandleViewText(OGLVIEW* oglView)
    {
        if (!(mShowNames || mShowDims))
            return;

        OGLIMAGE*   oglIm = oglView->im;
        int         txtX  = oglView->x;
        int         txtY  = oglView->y-14;
        std::string txt   = "";

        if (mShowNames)
        {
            int userData1 = (long long)oglView->UserData1;
#ifndef NO_RAW
            if (mRgbDataSrc)
                txt = "im " + MakeString(userData1) + " ";
            else
#endif
                txt = *mFileNames[userData1] + " ";
        }
        if (mShowDims)
        {
            char buf[20];
            sprintf(buf, "[%dx%d]", oglIm->w, oglIm->h);
            txt += buf;
        }
        oglSys.StartScissor(mOglWnd,txtX,txtY-4,oglView->w,20);
        oglSys.PosColPrintf(mOglWnd,txtX,txtY,GetForeground(),"%s",txt.c_str());
        oglSys.EndScissor();
    }

    void HandleViewZoom(OGLVIEW* oglView)
    {
        OGLIMAGE*   oglIm = oglView->im;
        float       zoomX, zoomY;

        if (oglIm->w >= oglIm->h)
            zoomY = zoomX = (oglView->w)/(float)oglIm->w;
        else
            zoomX = zoomY = (oglView->h)/(float)oglIm->h;
        if (zoomX > mMaxZoom)
            zoomX = zoomY = mMaxZoom;
        viewSys.SetZoom(oglView, zoomX, zoomY);
    }

    virtual void HandleViewDecoration(OGLVIEW* view)
    {
        SetSolidLineColor(oglLIGHTGREY);
        DrawRectangle(view->x-2, view->y-2, view->w+4, view->h+4);
    }

    void HandleViewSettings(int vIdx)
    {
        OGLVIEW*  oglView;
        if (vIdx<0 || vIdx>mViews.size() || !(oglView=mViews[vIdx]))
            return;
        if (!mViews[vIdx]->im)
            return;
        HandleViewZoom(oglView);
        HandleViewText(oglView);
        HandleViewDecoration(oglView);
    }

    void ViewCreateImage(int dstIdx, int imIdx)
    {
            Array2dVec3UInt8* ar = 0;
#ifndef NO_RAW
        if (mRgbDataSrc)
        {
            mRgbDataSrc->GotoFrame(imIdx);
            int imW = mRgbDataSrc->FrameWidth();
            int imH = mRgbDataSrc->FrameHeight();
                ar = new Array2dVec3UInt8(imW, imH, 0, 0, 0, false);
                memcpy( (void *) ar->CPB(0, 0), mRgbDataSrc->DataPtr(), imW*imH*3 );
        }
        else
#endif
        {
            std::string fName = mDirName + "/" + *mFileNames[imIdx];
#ifndef REPOSITORY_USED // Here comes the deprecated stuff
            Core::Array::ReadFile(ar, fName, &Util::Database::GetInstance());
#else // REPOSITORY_USED
            // This is just a hack to get things to compile...
            Persistency::FileLocator loc(fName);
            typedef Persistency::RepositoryInFileSystem FS;
            Persistency::File f = FS::GetInstance().GetFile(loc, false, false);
            Core::Array::ReadFile(ar, f);
#endif // REPOSITORY_USED
            if (ar == 0)
            {
                ILOG_WARN("Could not read file: " << fName);
            }
        }
        if (ar != 0)
        {
            OGLIMAGE* oglIm = RgbOglImage::OglImage(ar);
            viewSys.SetImage(mViews[dstIdx],oglIm);
            ReleaseOglImage(oglIm);
        } else {
            ILOG_WARN("array = 0, image not loaded.");
            viewSys.SetImage(mViews[dstIdx], 0);
        }
        mViews[dstIdx]->UserData1 = (void *) imIdx;
    }

    void CopyImageFromView(int dstIdx, int srcIdx, int imIdx)
    {
        viewSys.SetImage(mViews[dstIdx], mViews[srcIdx]->im);
        mViews[dstIdx]->UserData1 = (void *) imIdx;
    }

    bool ViewNewPositionNeedsIm(int vIdx, int imIdx)
    {
        int row = imIdx / mNrOfImOnRow;
        int x   = (imIdx%mNrOfImOnRow) * mCellW + 4;
        int y   = Row2Y(row) + 12 + mExtH;
        int w   = mCellW - 8;
        int h   = mCellH - (18+mExtH);

        viewSys.SetDimensions(mViews[vIdx], x, y, w, h);
        viewSys.SetTags(mViews[vIdx], visibleTag);
        return ((long long) mViews[vIdx]->UserData1) != imIdx;
    }

    virtual void ReshapeFunc(int w, int h)
    {
        Window::ReshapeFunc(w,h);
        HandleDocDimensions(true,false);
    }

    void HandleView(int vIdx, int imIdx, bool bwd)
    {
        if (vIdx < 0 || vIdx > mViews.size()-1)
            return;
        if (ViewNewPositionNeedsIm(vIdx,imIdx))
        {
            int foundIdx;
            if ((foundIdx = FindIndex(imIdx,vIdx,bwd))!=-1)
                CopyImageFromView(vIdx,foundIdx,imIdx);
            else
                ViewCreateImage(vIdx,imIdx);
        }
        HandleViewSettings(vIdx);
    }

    virtual void DisplayFunc()
    {
        int cellH = CellHeight();
        int h     = H();
        int dif   = (cellH > h) ? h-cellH : h % cellH;

        mFlowDragger.SetFlowPageExtra(dif-mPagingExtra);
        mFlowDragger.FlowDragDisplay();
        OGC myOGC;
        OGCSave(&myOGC);
        int first  = FindFirstVisible();
        int last   = FindLastVisible();
        int range  = last - first + 1;
        int i, vIdx;
        if (mOldStartIm <= first)
        {
            for (i=first, vIdx=-1; i<=last; i++)
                HandleView(++vIdx,i,false);
            ClearViews(vIdx+1);
        }
        else
        {
            for (i=last, vIdx=range; i>=first; i--)
                HandleView(--vIdx, i, true);
            ClearViews(range);
        }
        mOldStartIm = first;
        OGCRestore(&myOGC);
        Window::DisplayFunc();
    }

    virtual void KeyboardFunc(int c, int state)
    {
        int oldDocY = mDocY;
        mFlowDragger.KeyboardFunc(c,state);

        if (c == '~')
            mFixedCellDims = !mFixedCellDims;

        Window::KeyboardFunc(c, state);

        if (oldDocY != mDocY) // In case keys mapped to external scroller
            return;
        if (c==oglPAGEDOWN)
            mDocY += H();
        if (c==oglPAGEUP)
            mDocY -= H();
        if (c==oglUP)
            mDocY += 10;
        if (c==oglDOWN)
            mDocY -= 10;
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        mFlowDragger.MouseFunc(msg,but,state,x,y);
        Window::MouseFunc(msg,but,state,x,y);
    }

private:

    void Init(int w, int h, int nOnRow)
    {
        mFlowDragger.SetDocWnd(this,this);
        SetDocDimensions(0,0,w,h);
        ShowNames(true);
        ShowDims(true);
        FixedCellWidth(132); // Would result in fixed cell width, but overruled by next line
        NrOfImOnRow(nOnRow); // Results in fixed nr of im per row and scaling views
        ShowNames(true);
        ShowDims(true);
        mOldStartIm = -1;
        mPagingExtra = 1;
        mMaxZoom = 2;
        for (int i=0; i<1000; i++)
        {
            OGLVIEW* view = viewSys.View2D(mOglWnd,0,0,0,128,128);
            viewSys.SetTags(view, FlexViewTags);
            viewSys.ClearTags(view, visibleTag|showBorderTag|showBgTag|selectableTag);
            //viewSys.ClearTags(view, visibleTag|showBgTag|selectableTag);
            viewSys.SetColor(view, OGL_BG, oglTrLIGHTGREY);
            view->UserData1 = (void *) -1;
            mViews.push_back(view);
        }
#ifndef NO_RAW
        mRgbDataSrc = 0;
#endif
    }

    std::string                 mDirName;
    std::vector<std::string*>   mFileNames;
    std::vector<OGLVIEW*>       mViews;
#ifndef NO_RAW
    RgbDataSrc*                 mRgbDataSrc;
#endif

    bool                        mFixedCellDims;
    bool                        mShowNames;
    bool                        mShowDims;
    int                         mNrOfImOnRow;
    int                         mCellW;
    int                         mCellH;
    int                         mExtH;

    int                         mOldStartIm;
    int                         mPagingExtra;

    double                      mMaxZoom;
    OglGui::DocFlowDrag         mFlowDragger;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(DirImViewer, Visualization);

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

---