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

---

ViewerPointCloudNavigator.h

Go to the documentation of this file.

//345678901234567890123456789012345678901234567890123456789012345678901234567890
#ifndef OglGui_ViewerPointCloudNavigator_h
#define OglGui_ViewerPointCloudNavigator_h

#ifndef OglGui_ViewerPointCloud_h
#include "OglGui/ViewerPointCloud.h"
#endif

namespace OglGui
{

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

    void SetTarget(ViewerPointCloud* vpc)
    {
        mViewerPointCloud = vpc;
    }

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

    void PointSize(float ptSize)
    {
        mPtSize = ptSize < 1.f ? 1.f : ptSize;
    }

    void ShowVisiblePart()
    {
        float vpcW = mViewerPointCloud->W();
        float vpcH = mViewerPointCloud->H();
        float virtX1 = mMinX, virtY1 = mMinY;
        float virtX2 = mMaxX, virtY2 = mMaxY;

        mViewerPointCloud->Point2Wnd(virtX1, virtY1);
        mViewerPointCloud->Point2Wnd(virtX2, virtY2);

        float x1 = (-virtX1/(virtX2-virtX1)) * W();
        float y1 = (-virtY1/(virtY2-virtY1)) * H();
        float x2 = ((-virtX1+vpcW)/(virtX2-virtX1)) * W();
        float y2 = ((-virtY1+vpcH)/(virtY2-virtY1)) * H();

        SetSolidFillColor(mVisiblePartColor);
        int bInfo[3];
        oglSys.StartBlend(bInfo);
        FillRectangle(x1, y1, x2-x1, y2-y1);
        SetSolidLineColor(oglBLACK);
        DrawRectangle(x1, y1, x2-x1, y2-y1);
        oglSys.EndBlend(bInfo);
    }

    virtual void DisplayFunc()
    {
        OGC     myOGC;

        OGCSave(&myOGC);
        int motion = oglSys.GetAllMouseMotion(mViewerPointCloud->GetOGLWND());
        oglSys.SetAllMouseMotion(mOglWnd, motion);

        Window::DisplayFunc();

        if (!mViewerPointCloud)
            return;

        if (mObtainMinMax)
            mViewerPointCloud->GetMinMax(mMinX, mMinY, mMaxX, mMaxY);
        if (mDoShow)
            mViewerPointCloud->DrawPointsEx(0.f, 0.f, -mMinX, -mMinY, mPtSize,
                                            W()/(mMaxX-mMinX),H()/(mMaxY-mMinY),
                                            W(), H());
        ShowVisiblePart();
        OGCRestore(&myOGC);
    }

    void ToViewerPointCloudMouse(int msg, int btn, int state, int x, int y)
    {
        float   virtX1 = mMinX, virtX2 = mMaxX;
        float   virtY1 = mMinY, virtY2 = mMaxY;

        mViewerPointCloud->Point2Wnd(virtX1, virtY1);
        mViewerPointCloud->Point2Wnd(virtX2, virtY2);

        int vpcX = virtX1 + (x/(float)W()) * (virtX2-virtX1);
        int vpcY = virtY1 + (y/(float)H()) * (virtY2-virtY1);

        mViewerPointCloud->MouseFunc(msg, btn, state, vpcX, vpcY);
    }

    virtual void KeyboardFunc(int c, int state)
    {
        if (c=='P') PointSize(mPtSize+0.5f);
        if (c=='p') PointSize(mPtSize-0.5f);
        if (c=='S') mDoShow = !mDoShow;

        mViewerPointCloud->KeyboardFunc(c, state);
    }

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

        Window::MouseFunc(msg, btn, state, x, y);
        if (msg == oglMouseDown && btn == oglRightButton)
        {
            isDragging = true;
            lastX = x;
        }

        if (msg == oglMouseUp)
            isDragging = false;

        if (!isDragging)
        {
            ToViewerPointCloudMouse(msg, btn, state, x, y);
            return;
        }

        if (state&oglShift)
        {
            float scale = mViewerPointCloud->Scale();
            mViewerPointCloud->Scale(scale * (1.f+((x - lastX)/50.f)));
        }
        else
        {
            float   vpcW = mViewerPointCloud->W();
            float   vpcH = mViewerPointCloud->H();
            float   xFact = x / (float) W();
            float   yFact = y / (float) H();
            float   pX = (vpcW/2) - (mMinX+(xFact * (mMaxX-mMinX)));
            float   pY = (vpcH/2) - (mMinY+(yFact * (mMaxY-mMinY)));
            mViewerPointCloud->SetPtDocXY(pX, pY);
        }
        lastX = x;
    }

private:
    void Init(int w, int h)
    {
        mViewerPointCloud = 0;
        mDoShow = true;
        mPtSize = 1.f;
        mObtainMinMax = true;
        mMinX = 0;
        mMaxX = w;
        mMinY = 0;
        mMaxY = h;
        mVisiblePartColor = oglTrWHITE;
    }

    ViewerPointCloud* mViewerPointCloud;

    bool    mDoShow;
    ULONG   mVisiblePartColor;
    float   mPtSize;
    bool    mObtainMinMax;
    float   mMinX, mMaxX;
    float   mMinY, mMaxY;
};

} // namespace OglGui
#endif

---