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

---

ViewerPointCloud.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef OglGui_ViewerPointCloud_h
#define OglGui_ViewerPointCloud_h

#ifndef OglGui_Window_h
#include "OglGui/Window.h"
#endif

#ifndef OglGui_ViewerPoint_h
#include "OglGui/ViewerPoint.h"
#endif

#ifndef OglGui_SetImageInterface_h
#include "OglGui/SetImageInterface.h"
#endif

#ifndef OglGui_GetOglImageByIdInterface_h
#include "OglGui/GetOglImageByIdInterface.h"
#endif

#ifndef OglGui_OglImageCache_h
#include "OglGui/OglImageCache.h"
#endif

namespace OglGui {

class ViewerPointCloud : public Window
{
public:
    static const int cMaxPoints = 10000;

    ViewerPointCloud(int x, int y, int w, int h) :
        Window(x, y, w, h)
        {
        Init(w,h);
        }

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

    void DetailImageInterface(SetImageInterface* si)
    {
        mDetailImageI = si;
    }

    void SetOglImageCache(OglImageCache* oglImageCache)
    {
        mOglImageCache = oglImageCache;
    }

    void SetGetOglImageByIdInterface(GetOglImageByIdInterface* i)
    {
        mGetOglImageByIdI = i;
    }

    OGLIMAGE* LoadViewImage(ViewerPoint* vp)
    {
        if (!vp || !mGetOglImageByIdI)
            return 0;

        OGLIMAGE* im = 0;
        long long id = vp->GetId();
        if (mOglImageCache)
        {
            im = mOglImageCache->GetImage(id);
            im ? mCacheHits++ : mCacheMisses++;
        }

        if (!im && (im = mGetOglImageByIdI->GetOglImageById(id)))
            if (mOglImageCache)
                mOglImageCache->Add(im, id);
        return im;
    }

    OGLIMAGE* LoadViewImage(OGLVIEW* oglView)
    {
        if (!oglView || !(oglView->SysData2 == (void*) ViewerPoint::cMagicNr))
            return 0;
        ViewerPoint* vp = (ViewerPoint*) oglView->SysData1;
        return LoadViewImage(vp);
    }

    int   NrOfPoints()            { return mNrOfPoints; }
    float PtDocX()                { return mPtDocX; }
    float PtDocY()                { return mPtDocY; }
    float MinX()                  { return mMinX; }
    float MinY()                  { return mMinY; }
    float MaxX()                  { return mMaxX; }
    float MaxY()                  { return mMaxY; }
    void  MaxVisibleImages(int m) { mMaxVisibleImages = m; }
    int   MaxVisibleImages()      { return mMaxVisibleImages; }
    void  Scale(float s)          { mScale=(s>mMinimumScale) ? s:mMinimumScale;}
    float Scale()                 { return mScale; }
    void  MinimumScale(float s)   { mMinimumScale = s; }   
    float MinimumScale()          { return mMinimumScale; }

    void  ScaleThreshold(float s) { mShowViewAtScale = s; }
    float ScaleThreshold()        { return mShowViewAtScale; }

    void SetPtDocXY(float x, float y)
    {
        mPtDocX = x;
        mPtDocY = y;
    }

    void GetMinMax(float& minX, float& minY, float& maxX, float& maxY)
    {
        minX = mMinX;
        minY = mMinY;
        maxX = mMaxX;
        maxY = mMaxY;
    }

    void Point2Wnd(float& x, float& y)
    {
        float hW = W()/2.f, hH = H()/2.f;
        x  = hW + mScale * (x-hW+mPtDocX);
        y  = hH + mScale * (y-hH+mPtDocY);
    }

    void Wnd2Point(float&x, float& y)
    {
        float hW = W()/2.f, hH = H()/2.f;
        x = (x - hW)/mScale + hW - mPtDocX;
        y = (y - hH)/mScale + hH - mPtDocY;
    }

    static LIST *FindViewNodeOnOfTagged(OGLWND *oglWnd, int x, int y,
                                        int onTags, int offTags)
    {
        LIST         *obj;
        OGLVIEW      *view;

        ForAllElementsBackward(obj, oglWnd->lastObject)
        {
            view = (OGLVIEW *) obj->info;
            if (((view->tags & onTags)==onTags) && !(view->tags&offTags))
                if( viewSys.PointInView( view, x, y ) )
                    return obj;
        }
        return NULL;
    }

    // Could become standard part of viewSys
    static OGLVIEW* FindViewOnOfTagged(HOGLWND oglWnd, int x, int y,
                                       int onTags, int offTags)
    {
        LIST    *obj = FindViewNodeOnOfTagged(oglWnd, x, y, onTags, offTags);
        return obj ? (OGLVIEW*) obj->info : NULL;
    }

    void BorderColorTagged(int tags, bool isSet, ULONG col)
    {
        LIST   *obj, *objList = mOglWnd->objectList;
        ForAllElements(obj, objList)
        {
            OGLVIEW*    view = (OGLVIEW*) obj->info;
            bool        hasTags = (view->tags & tags) == tags;

            if ((isSet && hasTags) || (!isSet && !hasTags))
                view->borderCol = col;
        }
    }

    void TagBorderColor(ULONG col, int tag, bool mode)
    {
        LIST   *obj, *objList = mOglWnd->objectList;
        ForAllElements(obj, objList)
        {
            OGLVIEW*    view = (OGLVIEW*) obj->info;
            if (view->borderCol == col)
                viewSys.SetTagsTo(view, tag, mode);
        }
    }

    void TagBorderColorOnOff(ULONG col, int onTag, int offTag)
    {
        LIST   *obj, *objList = mOglWnd->objectList;
        ForAllElements(obj, objList)
        {
            OGLVIEW*    view = (OGLVIEW*) obj->info;
            if (view->borderCol == col)
            {
                viewSys.SetTagsTo(view, onTag, true);
                viewSys.SetTagsTo(view, offTag, false);
            }
        }
    }

    void HandleDragging()
    {
        float   w = W();
        float   h = H();
        float   hW = W()/2.f, hH = H()/2.f;
        float   offX = hW - mPtDocX;
        float   offY = hH - mPtDocY;

        LIST   *obj, *objList = mOglWnd->objectList;
        ForAllElements(obj, objList)
        {
            OGLVIEW*     view = (OGLVIEW*) obj->info;
            if (!(view->SysData2 == (void*)ViewerPoint::cMagicNr))
                continue;
            ViewerPoint* vp = (ViewerPoint*) view->SysData1;

            if (view->tags & selectedTag)
                vp->PointXY((view->x + view->w/2.f - hW)/mScale + offX,
                            (view->y + view->h/2.f - hH)/mScale + offY);
        }
    }

    void HandleMouseOver(int x, int y)
    {
        OGLVIEW* view = FindViewOnOfTagged(mOglWnd, x, y, 0, ignoreTag);
        OGLIMAGE* im = viewSys.GetImage(view);
        if (!im)
            im = LoadViewImage(view);
        mDetailImageI->SetImage(im);
        ReleaseOglImage(im);
    }


    // Service for outsiders, like the ViewerPointCloudNavigator
    void DrawPointsEx(float trX, float trY, float offX, float offY,
                      float ptSize, float scaleX, float scaleY,
                      int wndW, int wndH)
    {
        LIST   *obj, *objList = mOglWnd->objectList;
        ULONG   selCol = mOglWnd->selectCol;

        glPushMatrix();
        ptSize = (ptSize < 1.f) ? 1.f : ptSize;
        glPointSize(ptSize);
        glTranslatef(trX, trY, 0.f);
        glScalef(scaleX, scaleY, 1.f);

        glBegin(GL_POINTS);
        ForAllElements(obj, objList)
        {
            OGLVIEW*    view = (OGLVIEW*) obj->info;
            if ((view->tags & ignoreTag) ||
                !(view->SysData2 == (void*)ViewerPoint::cMagicNr))
                continue;
            bool  selected = (view->tags & selectedTag) != 0;
            ViewerPoint* vp = (ViewerPoint*) view->SysData1;
            float x = vp->PointX() + offX; 
            float y = vp->PointY() + offY;
            ULONG   borderCol = view->borderCol;
            SetColor(selected ? selCol : borderCol);
            glVertex2f(x, y);
            if (selected && ptSize >= 3.f)
            {
                glEnd();
                glPointSize(ptSize-2);
                glBegin(GL_POINTS);
                UCHAR   r, g, b;
                COLOR2RGB(borderCol, r, g, b);
                glColor3ub(r, g, b);
                glVertex2f(x, y);
                glEnd();
                glPointSize(ptSize);
                glBegin(GL_POINTS);
            }
        }
        glEnd();
        glPopMatrix();
    }

    void
    DrawAsPoints(float trX, float trY, float offX, float offY, float ptSize)
    {
        ULONG   selCol = mOglWnd->selectCol;
        int     wndW = W(), wndH = H();
        float   hW = wndW/2.f, hH = wndH/2.f;
        int     vW = (mScale > 1.f) ? mScale : 1;
        int     vH = (mScale > 1.f) ? mScale : 1;
        float   hVW = vW/2.f, hVH = vH/2.f;
        float   minHWPlusPtDocX = -hW+mPtDocX;
        float   minHHPlusPtDocY = -hH+mPtDocY;

        mMinX = mMinY = 1000000;
        mMaxX = mMaxY = -1000000;
        mNrOfPoints = 0;
        glPushMatrix();
        ptSize = (ptSize < 1.f) ? 1.f : ptSize;
        glPointSize(ptSize);
        glTranslatef(trX, trY, 0.f);
        glScalef(mScale, mScale, 1.f);

        glBegin(GL_POINTS);
        LIST   *obj, *objList = mOglWnd->objectList;
        ForAllElements(obj, objList)
        {
            OGLVIEW*     view = (OGLVIEW*) obj->info;
            if (!(view->SysData2 == (void*) ViewerPoint::cMagicNr))
                continue;
            ViewerPoint* vp = (ViewerPoint*) view->SysData1;
            mNrOfPoints++;
            view->tags &= ~visibleTag;
            if (view->tags & ignoreTag)
                continue;
            if (mAnimation && mStarted)
                vp->AnimatePoint();
            if (mOglImageCache)
                viewSys.SetImage(view,0);
            float   x = vp->PointX(), y = vp->PointY();
            float   wndX  = hW + mScale * (x+minHWPlusPtDocX);
            float   wndY  = hH + mScale * (y+minHHPlusPtDocY);
            view->w = vW;
            view->h = vH;
            int vX = view->x = wndX - hVW;
            int vY = view->y = wndY - hVH;

            if (x<mMinX) mMinX = x;
            if (x>mMaxX) mMaxX = x;
            if (y<mMinY) mMinY = y;
            if (y>mMaxY) mMaxY = y;

            if (vX+vW<0 || vY+vH<0 || vX > wndW || vY > wndH)
                continue;

            bool    selected = (view->tags & selectedTag) != 0;
            ULONG   borderCol = view->borderCol;
            SetColor(selected ? selCol : borderCol);

            glVertex2f(x+offX, y+offY);
            if (selected && ptSize >= 3.f)
            {
                glEnd();
                glPointSize(ptSize-2);
                glBegin(GL_POINTS);
                UCHAR   r, g, b;
                COLOR2RGB(borderCol, r, g, b);
                glColor3ub(r, g, b);
                glVertex2f(x+offX, y+offY);
                glEnd();
                glPointSize(ptSize);
                glBegin(GL_POINTS);
            }
        }
        glEnd();
        glPopMatrix();
    }

    void HandleViewDisplay(int w, int h)
    {
        float   hW = w/2.f, hH = h/2.f;
        float   minHWPlusPtDocX = -hW+mPtDocX;
        float   minHHPlusPtDocY = -hH+mPtDocY;
        int     nrVisible = 0;

        mMinX = mMinY = 1000000;
        mMaxX = mMaxY = -1000000;
        mNrOfPoints = 0;
        LIST   *obj, *objList = mOglWnd->objectList;
        ForAllElements(obj, objList)
        {
            OGLVIEW*     view = (OGLVIEW*) obj->info;
            if (!(view->SysData2 == (void*) ViewerPoint::cMagicNr))
                continue;
            ViewerPoint* vp = (ViewerPoint*) view->SysData1;
            mNrOfPoints++;
            if (view->tags & ignoreTag)
                continue;
            if (mAnimation && mStarted)
                vp->AnimatePoint();

            float   x     = vp->PointX(), y = vp->PointY();
            float   wndX  = hW + mScale * (x+minHWPlusPtDocX);
            float   wndY  = hH + mScale * (y+minHHPlusPtDocY);
            int     zW = mScale;
                        if(view->im && view->im->w && view->im->h)
                                zW *= view->im->w/(float)view->im->h;
                        int     vW = view->w = zW;
            int     vH = view->h = mScale;
            int     vX = view->x = wndX - vW/2.f;
            int     vY = view->y = wndY - vH/2.f;

            if (x<mMinX) mMinX = x;
            if (x>mMaxX) mMaxX = x;
            if (y<mMinY) mMinY = y;
            if (y>mMaxY) mMaxY = y;

            if (vX+vW > 0 && vX < w && vY+vH > 0 && vY < h)
            {
                view->tags |= visibleTag;
                if (++nrVisible > mMaxVisibleImages && mOglImageCache)
                {
                    viewSys.SetImage(view, 0);
                    continue;
                }
                if (view->im || (view->im = LoadViewImage(vp)))
                {
                    view->zoomX = vW / (float) view->im->w;
                    view->zoomY = vH / (float) view->im->h;
                }
            }
            else
            {
                view->tags &= ~visibleTag;
                if (view->im && mOglImageCache)
                    viewSys.SetImage(view,0);
            }
        }
    }

    // To prevent handling many compute intensive move messages
    void HandleMouseMoveOnDisplay()
    {
        if (mMouseMsg==oglMouseMove && !mMouseState)
            if (mAllMouseMotion && mDetailImageI)
                HandleMouseOver(mMouseX, mMouseY);

        trickFindInvisibleView = 1;
        Window::MouseFunc(mMouseMsg, mMouseBtn, mMouseState, mMouseX, mMouseY);
        trickFindInvisibleView = 0;
        mMouseMoveOnDisplay = false;
        if (mOglWnd->dragging)
            HandleDragging();
    }

    virtual void DisplayFunc()
    {
        OGC     myOGC;
        ULONG   ptColor = oglRED;
        int     w = mOglWnd->width;
        int     h = mOglWnd->height;

        if (mMouseMoveOnDisplay)
            HandleMouseMoveOnDisplay();

        OGCSave(&myOGC);

        if (mScale < mShowViewAtScale)
            DrawAsPoints(w/2.f, h/2.f, mPtDocX-w/2.f, mPtDocY-h/2.f, mScale);
        else
            HandleViewDisplay(w, h);
        Window::DisplayFunc();

        SetSolidLineColor(0xff00ffff);
        DrawLine(w/2-8, h/2, w/2+9, h/2);
        DrawLine(w/2, h/2-8, w/2, h/2+9);
        OGCRestore(&myOGC);
    }

    virtual void ReshapeFunc(int w, int h)
    {
        float   diffX = mPtDocX - (mOldW/2.f);
        float   diffY = mPtDocY - (mOldH/2.f);

        mPtDocX = diffX + w/2.f; 
        mPtDocY = diffY + h/2.f;
        mOldW = w;
        mOldH = h;
    }

    void HandleWindowMouse(int msg, int btn, int state, int x, int y)
    {
        if (msg != oglMouseMove)
        {
            trickFindInvisibleView = 1;
            Window::MouseFunc(msg, btn, state, x, y);
            trickFindInvisibleView = 0;
        }
        else
        {
            mMouseMoveOnDisplay = true;
            mMouseMsg = msg;
            mMouseBtn = btn;
            mMouseState = state;
            mMouseX = x;
            mMouseY = y;
        }
    }

    virtual void MouseFunc(int msg, int btn, int state, int x, int y)
    {
        static bool  isDragging = false;
        static float markX, markY, markDocX, markDocY;
        static int   lastX;

        if (msg == oglMouseWheelUp)
        {
            // mouse position based zooming, implemented as follows:
            // transform coordinates of window, mouse and nodes to -0.5 .. +0.5,
            // jump node under mouse to center, scale with 1.1f into center
            // and unjump. 
            float xd = (x / (float)W()) - 0.5f;
            float yd = (y / (float)H()) - 0.5f;
            float x = mPtDocX / W()-0.5f;
            float y = mPtDocY / H()-0.5f;
            x -= xd/mScale;
            y -= yd/mScale;
            int jumpX=mPtDocX, jumpY=mPtDocY;
            mPtDocX = (int)((x+0.5f) * W());
            mPtDocY = (int)((y+0.5f) * H());
            jumpX -= mPtDocX;
            jumpY -= mPtDocY;
            Scale(mScale * (1.1f));
            jumpX = (float)jumpX / 1.1f;
            jumpY = (float)jumpY / 1.1f;
            mPtDocX += jumpX;
            mPtDocY += jumpY;
        }
        if (msg == oglMouseWheelDown)
        {
            float xd = (x / (float)W()) - 0.5f;
            float yd = (y / (float)H()) - 0.5f;
            float x = mPtDocX / W()-0.5f;
            float y = mPtDocY / H()-0.5f;
            x -= xd/mScale;
            y -= yd/mScale;
            int jumpX=mPtDocX, jumpY=mPtDocY;
            mPtDocX = (int)((x+0.5f) * W());
            mPtDocY = (int)((y+0.5f) * H());
            jumpX -= mPtDocX;
            jumpY -= mPtDocY;
            Scale(mScale * (0.9f));
            jumpX = (float)jumpX / 0.9f;
            jumpY = (float)jumpY / 0.9f;
            mPtDocX += jumpX;
            mPtDocY += jumpY;
        }

        if (msg == oglMouseDown && btn == oglRightButton)
        {
            isDragging = true;
            markDocX = mPtDocX;
            markDocY = mPtDocY;
            markX = x;
            markY = y;
        }
        if (msg == oglMouseMove && isDragging)
        {
            if (state & oglShift)
                Scale(mScale * (1.f+((x - lastX)/50.f)));
            else
            {
                mPtDocX = markDocX + (x - markX)/mScale;
                mPtDocY = markDocY + (y - markY)/mScale;
            }
        }
        if (msg == oglMouseUp)
            isDragging = false;

        HandleWindowMouse(msg, btn, state, x, y);
        lastX = x;
    }

    virtual void KeyboardFunc(int c, int state)
    {
        if (c == 's')
            oglSys.SetAlwaysDraw(mOglWnd, mStarted = !mStarted);
        if (c == 'M')
            oglSys.SetAllMouseMotion(mOglWnd, mAllMouseMotion=!mAllMouseMotion);
        if (c == 'a')
            mAnimation = !mAnimation;
        if (c == 'c')
            printf("Hits %d Misses %d\n", mCacheHits, mCacheMisses);
        Window::KeyboardFunc(c, state);
    }

private:

    void Init(int w, int h)
    {
        //SetDisableOGLViewKeys(true);
        mDetailImageI = 0;
        mOglImageCache = 0;
        mGetOglImageByIdI = 0;
        mCacheHits = mCacheMisses = 0;

        mOldW = w;
        mOldH = h;
        mPtDocX = w/2;
        mPtDocY = h/2;
        mScale = 1.f;
        mMinX = mMinY = 1000000;
        mMaxX = mMaxY = -1000000;
        mMaxVisibleImages = 200;

        mMinimumScale = 0.25f;
        mShowViewAtScale = 16;

        mStarted = false;
        mAnimation = true;

        mMouseMoveOnDisplay = false;
        mAllMouseMotion = true;
        oglSys.SetAllMouseMotion(mOglWnd, mAllMouseMotion);
        oglSys.AllowPicking(mOglWnd, 1, 1);
        oglSys.AllowDeleteView(mOglWnd, 1);
    }

    ULONG   mColors[8];

    bool    mStarted;
    bool    mAnimation;

    bool    mAllMouseMotion;

    bool    mMouseMoveOnDisplay;

    int     mNrOfPoints;
    int     mMaxVisibleImages;
    int     mMouseMsg, mMouseBtn, mMouseState, mMouseX, mMouseY;

    int     mOldW, mOldH;

    float   mPtDocX, mPtDocY;

    float   mMinX, mMaxX;
    float   mMinY, mMaxY;

    float   mScale;
    float   mMinimumScale;
    float   mShowViewAtScale;

    int     mCacheHits, mCacheMisses;

    SetImageInterface*  mDetailImageI;
    OglImageCache*      mOglImageCache;
    GetOglImageByIdInterface*   mGetOglImageByIdI;
};

} // namespace OglGui
#endif

---