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

---

ImageSetIdxGrid.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
// Author: Richard van Balen

#ifndef Impala_Visualization_ImageSetIdxGrid_h
#define Impala_Visualization_ImageSetIdxGrid_h

#include "OglGui/DocDimensions.h"
#include "OglGui/DocFlowDrag.h"
#include "Visualization/RgbOglImage.h"
#include "Visualization/ImageSetIdxGridListener.h"
#include "Core/ImageSet/ImageSet.h"

namespace Impala {
namespace Visualization {

class ImageSetIdxGrid :  public OglGui::Window,
                         public OglGui::DocDimensions
{
public:
    typedef OglGui::Window                  Window;
    typedef Core::Array::Array2dVec3UInt8   Array2dVec3UInt8;
    typedef Core::ImageSet::ImageSet        ImageSet;

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

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

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

    ~ImageSetIdxGrid()
    {
        Clear();
    }

    void SetImageSetIdxGridListener(ImageSetIdxGridListener* l,void* userData=0)
    {
        mListener = l;
        mListenerData = userData;
    }
    void
    SetImageSetIdxGridListener(ImageSetIdxGridListener* l, int userData)
    {
        SetImageSetIdxGridListener(l, (void*) (long long) userData);
    }

    void AddImageSetIdxs(ImageSet* imSet, int startIdx=0, int endIdx=-1)
    {
        if (!imSet || imSet->NrFiles()<=0)
            return;
        if (startIdx<0)
            startIdx = 0;
        if (endIdx == -1)
            endIdx = imSet->NrFiles()-1;
        if (endIdx < startIdx)
            endIdx = startIdx;
        for (int i = 0; i<endIdx; i++)
            AddImageSetIdx(imSet, i);
        HandleDocDimensions(true,true);
    }

    void AddImageSetIdx(ImageSet* imSet, int idx)
    {
        mImSets.push_back(imSet);
        mIdxs.push_back(idx);
    }

    // Obtain ImageSet Idx belonging to GridImIdx
    int ImageSetIdx(int imIdx)
    {
        if (imIdx<0 || imIdx >= mIdxs.size())
            return -1;
        return mIdxs[imIdx];
    }

    ImageSet* GetImageSet(int imIdx)
    {
        if (imIdx<0 || imIdx >= mIdxs.size())
            return 0;
        return mImSets[imIdx];
    }

    std::vector<OGLVIEW*>* OglViews()
    {
        return &mViews;
    }

    void UpdateLayout(bool reset=false)
    {
        HandleDocDimensions(false,reset);
    }

    void Clear()
    {
        SetSelected(-1);
        ClearViews();
        mImSets.clear();
        mIdxs.clear();
        UpdateLayout(true);
    }

    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; }
    int  NrOfFiles()                { return mIdxs.size(); }

    int X2Column(int x)             { return x / mCellW; }
    int Column2X(int col)           { return col * mCellW; }
    int Y2Row(int y)
    {
        int res = (mDocY + mDocH - y) / mCellH;
        return (mDocY + mDocH - y) / mCellH;
    }
    int Row2Y(int row)              { return (mDocY+mDocH-(row+1)*mCellH); }
    int NrRows()                    { return NrOfFiles() / mNrOfImOnRow; }

    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 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;
        }
    }
/*
    bool IsVisible(int idx)
    {
        int first = FindFirstVisible();
        int last  = FindLastVisible();
        return (idx>=first && idx<last);
    }

    void MakeVisible(int idx)
    {
        //if (!IsVisible(idx))
            SetFirstVisRow(idx);
    }
*/
    void SetFirstVisRow(int idx)
    {
        int row = idx / mNrOfImOnRow;
        int yDiff = (H()-mCellH) - Row2Y(row);
        mDocY += yDiff; 
    }

    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 == (int)(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 == (int) (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 + 1) * mCellH;

        if (resizing && mOldStartIm != -1)
        {
            int row = mOldStartIm / mNrOfImOnRow;
            mDocY = H() - (NrRows() - row + 1) * 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         idx   = (int)(long long)oglView->UserData1;
        int         txtX  = oglView->x;
        int         txtY  = oglView->y-14;
        std::string txt   = "";

        if (mShowNames)
            txt = mImSets[idx]->GetFile(mIdxs[idx]) + " ";
        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 = 1, zoomY = 1;

        if (oglIm->w >= oglIm->h)
            zoomY = zoomX = (mCellW-8)/(float)oglIm->w;
        else if (oglIm->w<oglIm->h)
            zoomX = zoomY = (mCellH-(8+mExtH))/(float)oglIm->h;
        if (zoomX > 2) // Refuse zooming more than 2
            zoomX = zoomY = 2;
        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 = mImSets[imIdx]->GetImage(mIdxs[imIdx]);
        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 ((int)(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);
    }

    void SetSelected(int idx)
    {
        SetSelectedMode(mLastSelected, false);
        SetSelectedMode(mLastSelected=idx,true);
    }

    void SetSelectedMode(int idx, bool mode)
    {
        if (idx < 0 || idx >= mIdxs.size())
            return;
        int vIdx = FindIndexFwd(idx);
        if (vIdx >=0 && vIdx < mViews.size())
        {
            if (mode)
            {
                ULONG col = oglSys.GetSelectColor(mViews[0]->oglWnd);
                viewSys.SetTags(mViews[vIdx],selectedTag);
                viewSys.SetColor(mViews[vIdx],OGL_BG,col);
            }
            else
            {
                viewSys.ClearTags(mViews[vIdx],selectedTag);
                viewSys.SetColor(mViews[vIdx],OGL_BG,0);
            }
        }
    }

    virtual void DisplayFunc()
    {
        int dif = H() % CellHeight();
        mFlowDragger.SetFlowPageExtra(dif-1);
        mFlowDragger.FlowDragDisplay();

        OGC myOGC;
        OGCSave(&myOGC);
        int first  = FindFirstVisible();
        int last   = FindLastVisible();
        int range  = last - first + 1;
        int i, vIdx;

        int oldLastSelected = mLastSelected;
        SetSelected(-1);
        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);
        }
        SetSelected(oldLastSelected);

        mOldStartIm = first;
        OGCRestore(&myOGC);
        Window::DisplayFunc();
    }

    virtual void
    MouseFunc(int msg, int but, int state, int x, int y)
    {
        if (!GetState()) return;

        mFlowDragger.MouseFunc(msg,but,state,x,y);
        Window::MouseFunc( msg, but, state, x, y );

        if (state & (oglAlt|oglShift|oglControl))
            return;

        if (msg == oglMouseDown && but == oglLeftButton)
        {
            int idx = Y2Row(y) * mNrOfImOnRow + X2Column(x);
            if (idx >= 0 && idx < NrOfFiles())
            {
                SetSelected(idx);
                if (mListener!=0)
                    mListener->ImageSelectionEvent(this,idx,mListenerData);
            }
        }
    }

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

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

        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;
    }

private:

    void Init(int w, int h, int nOnRow)
    {
        mListener = 0;
        mFlowDragger.SetDocWnd(this,this);
        SetDocDimensions(0,0,w,h);
        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);
        mLastSelected = -1;
        mOldStartIm = -1;
        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|selectableTag|panableTag|zoomableTag);
            viewSys.SetColor(view, OGL_BG, 0);
            view->UserData1 = (void *) -1;
            mViews.push_back(view);
        }
    }

    ImageSetIdxGridListener*    mListener;
    void*                       mListenerData;

    std::vector<int>            mIdxs;
    std::vector<ImageSet*>      mImSets;
    std::vector<OGLVIEW*>       mViews;

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

    int                         mOldStartIm;

    OglGui::DocFlowDrag         mFlowDragger;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(ImageSetIdxGrid, Visualization);

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

---