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

---

DirImViewer3D.h

Go to the documentation of this file.

#ifndef Impala_Visualization_DirImViewer3D_h
#define Impala_Visualization_DirImViewer3D_h

#include "OglGui/TitledWindow.h"
#include "OglGui/Camera3DControlEx.h"

#include "OglGui/OglImageCache.h"
#include "OglGui/Window.h"

#include "Util/DirImageFileNames.h"
#include "Core/Array/ReadFile.h"
#include "Visualization/RgbOglImage.h"

#include "Core/Stream/RgbDataSrcRaw.h"

namespace Impala {
namespace Visualization {

class DirImViewer3D : public OglGui::Window
{
    typedef std::vector<String*>                StringPtrVector;
    typedef OglGui::OglImageCache               OglImageCache;
    typedef OglGui::Camera3DControlEx           Camera3DControlEx;
    typedef OglGui::TitledWindow                TitledWindow;

    typedef Core::Array::Array2dVec3UInt8       Array2dVec3UInt8;
    typedef Core::Stream::RgbDataSrc            RgbDataSrc;
    typedef Core::Stream::RgbDataSrcRaw         RgbDataSrcRaw;

public:
    DirImViewer3D(int x, int y, int w, int h,
                  int nrToShow=56, int cacheSize=112, bool camControl=true) :
        OglGui::Window(x, y, w, h, false)
    {
        Init(w, h, cacheSize, nrToShow, camControl);
    }

    DirImViewer3D(OglGui::Window* parent, int w, int h,
                 int nrToShow=56, int cacheSize=112, bool camControl=true) :
        OglGui::Window(parent, w, h, false)
    {
        Init(w, h, cacheSize, nrToShow, camControl);
    }

    DirImViewer3D(OglGui::Window* parent, int x, int y, int w, int h,
                  int nrToShow=56, int cacheSize=112, bool camControl=true) :
        OglGui::Window(parent, x, y, w, h, false)
    {
        Init(w, h, cacheSize, nrToShow, camControl);
    }

    void OpenDir(strconst dirName)
    {
        Clear();
        mDirName = dirName;
        std::string ext = FileNameExt(dirName, true);
        if (ext == "raw")
            mRgbDataSrc = new RgbDataSrcRaw(dirName);
        else
            Util::DirImageFileNames(dirName, mFileNames);
        InitViews();
    }

    void SetRgbDataSrc(RgbDataSrc* rgbDataSrc)
    {
        Clear();
        mRgbDataSrc = rgbDataSrc;
        InitViews();
    }

    void NrToShow(int nrToShow)
    {
        if (nrToShow < 8)   nrToShow = 8;
        if (nrToShow > 108) nrToShow = 108;
        mNrToShow = nrToShow;
    }

    void SetOglImageCache(OglImageCache* oglImCache, bool delOldCache=false)
    {
        if (oglImCache == mOglImageCache)
            return;
        if (delOldCache && mOglImageCache)
            delete mOglImageCache;
        mOglImageCache = oglImCache;
    }

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

    void Clear()
    {
        ClearFiles();
        ClearViews();
    }

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

    void ClearViews()
    {
        view3DSys.DeleteViews(mOglWnd);
        mViews.clear();
    }

    void InitViews()
    {
        ClearViews();

        int cnt     = 0;
        int d       = 0;
        int nrFiles = NrOfFiles();
        while (cnt < nrFiles)
        {
            d++;
            for (int y=1;  y>-2; y--)
            for (int x=-1; x<2;  x++)
            {
                if (!x && !y || cnt >= nrFiles)
                    continue;
                OGLVIEW3D* v = view3DSys.View3D(mOglWnd, 0, 3*x, 3*y,
                                                -5*d - (cnt++%8)*0.7143,
                                                1, 1, 1);
                mViews.push_back(v);
                view3DSys.SetTags(v, FlexViewTags & ~deletableTag);
                SetUpPrintingID(v, cnt-1);
                //FancySettings(v);
            }
        }
        if (mCam3DControlEx)
            mCam3DControlEx->MinMaxZ(-5*d-12, 12);
    }

    void InitDisplayFunc()
    {
        Window::InitDisplayFunc();

        float camZ;
        view3DSys.GetCamera(mOglWnd, 0, 0, &camZ, 0, 0, 0);

        int sz = mViews.size();
        for (int i=0; i<sz; i++)
        {
            float dist = camZ - mViews[i]->z;
            bool vis = dist > 1 && dist <= 1 + (mNrToShow*5)/8;
            HandleVisibility(i, vis);
        }
    }

    virtual void InitFunc()
        {
            Window::InitFunc();
        if (sTxtFontBase)
            return;

        void*   font;

#ifdef OGL_USING_GLUT
                sTxtFontBase = oglSys.Create3DFont( mOglWnd, font, 1, 0.6f, NULL );
#else
                font = (void*) CreateFont(
                        -12, 0, 0, 0, FW_NORMAL, 0, 0, 0,
                        ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS,
                        ANTIALIASED_QUALITY, VARIABLE_PITCH | FF_DONTCARE, "Verdana" );

                // Transform MsWindows fonts to OpenGL fontBases
                sTxtFontBase = oglSys.Create3DFont( mOglWnd, font, 1, 0.6f, NULL );
                DeleteObject( (HFONT) font ); // MsWindows font no longer needed
#endif
        }

private:
    OGLIMAGE* ReadImageIdx( int imIdx )
    {
            Array2dVec3UInt8*   ar = 0;
        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
        {
            String fName = mDirName + "/" + *mFileNames[imIdx];
            Core::Array::ReadFile(ar, fName, &Util::Database::GetInstance());
            if (ar == 0)
                ILOG_WARN("Could not read file: " << fName)
        }
        return RgbOglImage::OglImage(ar);
    }

    OGLIMAGE* LoadImageIdx(int id)
    {
        if (!mOglImageCache)
            return ReadImageIdx(id);

        OGLIMAGE* im;
        if (! (im = mOglImageCache->GetImage(id)) )
        {
            if (!(im = ReadImageIdx(id)))
                return 0;
            mOglImageCache->AddNoScalingTextured(im, id);
            // Next rather than above: When not using noTexScaling (SLOWER!)
            // mOglImageCache->Add(im, id);
        }
        return im;
    }

    void HandleVisibility(int id, bool visible)
    {
        OGLIMAGE*   im     = 0;
        OGLVIEW3D*  oglV3D = mViews[id];

        view3DSys.SetTagsTo(oglV3D, visibleTag, visible);
        if (!visible)
            view3DSys.SetImage(oglV3D,0);
        else if (!(im = oglV3D->im))
        {
            im = LoadImageIdx(id);
            view3DSys.SetImage(oglV3D, im);
            ReleaseOglImage(im);
        }

        if (!im) return;

        if (mDoAspectRatio)
        {
            float div = 100 * (1 + max(im->w, im->h)/200);
            oglV3D->w = im->w/div;
            oglV3D->h = im->h/div;
        }

        // Scale to viewer dims
        float tW = im->noTexScaling ? im->texW : im->w;
        float tH = im->noTexScaling ? im->texH : im->h;
        float zX = (oglV3D->w)*(tW/im->w);
        float zY = (oglV3D->h)*(tH/im->h);
        view3DSys.SetZoom(oglV3D, zX, zY);
    }

    void FancySettings(OGLVIEW3D* v)
    {
        //view3DSys.SetObject3D(v, OGL_CUBE);
        view3DSys.SetObject3D(v, 1+ABSRND(8));
        view3DSys.SetRotationSpeed(v, ABSRND(30)/300.0, ABSRND(30)/300.0, 1);
        SetAlwaysDraw(true);
    }

    static void MyOnDrawView(OGLVIEW3D* v)
    {
        StringPtrVector*  fileNames = (StringPtrVector*) v->UserData2;
        int               idx       = (int) (long long)  v->UserData1;
        char              buf[200];

        glPushMatrix();
                glColor3f( 0.0f, 1.0f, 0.0f );

        if (fileNames)
        {
            sprintf(buf, "%s", (*fileNames)[idx]->c_str());
                oglSys.Printf3D(sTxtFontBase, -v->w/2.f-0.1, -v->h/2.f - 0.15, 0.1f,
                            0.2f, 0.2f, 0.05f, buf);
        }
        else
        {
                sprintf(buf, "%d", idx);
                oglSys.Printf3D(sTxtFontBase, -0.1, -v->h/2.f - 0.15, 0.1f,
                            0.3f, 0.3f, 0.1f, buf);
        }
                glPopMatrix();
    }

    void SetUpPrintingID(OGLVIEW3D* v, int cnt)
    {
        v->UserData1 = (void *) cnt;
        v->UserData2 = (void *) (mRgbDataSrc ? 0 : &mFileNames);
        v->OnDrawView = MyOnDrawView;
    }

    void SetUpCameraControl3D()
    {
        int prefW, prefH;
        Camera3DControlEx::PreferredSize(prefW,prefH);

        TitledWindow* tWnd =
            new TitledWindow(this,10,10, prefW+8, prefH+32, "Camera3D Control");

        mCam3DControlEx = new Camera3DControlEx(tWnd, 0, 0, 10, 10, this);
        tWnd->SetContentPane(mCam3DControlEx);
        mCam3DControlEx->SetBorderType(0);
        mCam3DControlEx->MinMaxX(-6, 6);
        mCam3DControlEx->MinMaxY(-6, 6);
        mCam3DControlEx->MinMaxZ(-12, 12);
    }

    void Init(int w, int h, int cacheSize, int nrToShow, bool camControl)
    {
        NrToShow(nrToShow);
        mDoAspectRatio = true;
        mRgbDataSrc = 0;

        mOglImageCache = (cacheSize>0) ? (new OglImageCache(cacheSize)) : 0;

        oglSys.SetAllowCameraMove(mOglWnd, CamMove_Keys | CamMove_Mouse);
        oglSys.AllowPicking(mOglWnd, 1, 1);

        mCam3DControlEx = 0;
        if (camControl)
            SetUpCameraControl3D();
    }

    String                      mDirName;
    StringPtrVector             mFileNames;
    RgbDataSrc*                 mRgbDataSrc;

    std::vector<OGLVIEW3D*>     mViews;
    OglImageCache*              mOglImageCache;

    Camera3DControlEx*          mCam3DControlEx;

    bool                        mDoAspectRatio;
    int                         mNrToShow;

    static int                  sTxtFontBase;

    ILOG_VAR_DEC;
};

int DirImViewer3D::sTxtFontBase = 0;

ILOG_VAR_INIT(DirImViewer3D, Visualization);

} // namespace Visualization
} // namespace Impala

#endif // Impala_Visualization_DirImViewer3D_h

---