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

---

VideoMinimap.h

Go to the documentation of this file.

#ifndef Impala_Visualization_VideoMinimap_h
#define Impala_Visualization_VideoMinimap_h

#include "OglGui/Window.h"
#include "Basis/ILog.h"
#include "Core/Array/Arrays.h"
#include "Visualization/MapFunction.h"
#include "Core/Trec/Thread.h"
#include "Core/Trec/ThreadSet.h"
#include "Visualization/RotorBrowser/RotorBrowserContext.h"
#include "OglGui/WindowView2D.h"

namespace Impala {
namespace Visualization {

//using Core::Array::Array2dVec3UInt8;
//using Core::Array::Element::Vec3Int32;
//using Core::Trec::Thread;

typedef struct
{
    int x;
    int y;
    int count;
} MapCoordPos;

typedef struct
{
    int shot;
    double decay;
} ShotTrailPoint;

class ShotTrail
{
public:
    typedef Core::Array::Element::Vec3Int32             Vec3Int32;
    typedef Core::Trec::Thread                          Thread;

    ShotTrail(std::string name, int maxlength, Vec3Int32 color, double decay=0.0)
    {
        mMaxLength = maxlength;
        mDecay = decay;
        mBaseColor = color;
        mName = name;
    }

    void Push(int shot)
    {
        double d = 1.0;
        ShotTrailPoint p;
        p.shot = shot;
        p.decay = d;

        mShots.insert(mShots.begin(), p);
        int ctr=0;
        for (std::vector<ShotTrailPoint>::iterator i = mShots.begin(); i!=mShots.end(); i++)
        {
            if (ctr>0 && (*i).shot == shot)
            {
                i=mShots.erase(i);
                i--;
            }
            (*i).decay = d;
            d -= mDecay;
            ctr++; 
            if (d <= 0.0 || ctr > mMaxLength)
            {
                mShots.erase(i, mShots.end());
                break;
            }
        }
    }

    void
    Clear()
    {
        mShots.clear();
    }

    /* TODO: AddThread code: counts from end of list back to zero, so that
       Push will properly assign decay values.
       This isn't terribly efficient and can be done better by doing
       decay calculations here too.
    */
    void
    AddThread(Thread *t, int length)
    {
        for (int i=length-1;i>=0;i--)
        {
            int shot = t->GetShot(i);
            if (shot == -1)
                continue;
            Push(shot);
        }
    }

    void
    AddThread(Thread *t, int position, int direction, int length)
    {
        for (int i=length-1; i>=0;i--)
        {
            int shot = t->GetShotAt(position, direction * i);
            if (shot == -1)
                continue;
            Push(shot);
        }
    }

    void
    AddBrowserContext(RotorBrowser::RotorBrowserContext *c, int length, bool bidirectional=false)
    {
        if (bidirectional)
            length = length / 2;

        for (int i=length-1; i>=0; i--)
        {
            int shot = c->GetRelative(i);
            if (shot == -1)
                continue;
            Push(shot);
            if (bidirectional)
            {
                shot = c->GetRelative(-i);
                if (shot == -1)
                    continue;
                Push(shot);
            }
        }
    }

    std::string
    GetName()
    {
        return mName;
    }

    int
    GetLength()
    {
        return mShots.size();
    }

    int
    GetShot(int p)
    {
        return mShots[p].shot;
    }
    

    Vec3Int32
    GetColor(int p)
    {
        return DecayColor(mShots[p].decay);
    }

private:

    Vec3Int32 DecayColor(double dval)
    {
        return Vec3Int32(
            mBaseColor.X() * dval,
            mBaseColor.Y() * dval,
            mBaseColor.Z() * dval);
    }

    std::vector<ShotTrailPoint> mShots;
    int mMaxLength;
    double mDecay;
    Vec3Int32 mBaseColor;
    std::string mName;
};

class VideoMinimap : public OglGui::Window
{
public:
    typedef Core::Array::Array2dVec3UInt8               Array2dVec3UInt8;
    typedef Core::Array::Element::Vec3Int32             Vec3Int32;

    VideoMinimap(MapFunction *map, OglGui::Window *parent, int width, int height) :
        OglGui::Window(parent, width, height, true)
    {
        Init(map, width, height, parent);
    }

    VideoMinimap(MapFunction *map, OglGui::Window *parent, int x, int y, int width, int height) :
        OglGui::Window(parent, x, y, width, height, true)
    {
        Init(map, width, height, parent);
    }

    virtual void
    DisplayFunc()
    {
        static int counter = 1;
        static int color = 1;
        int w = mOglWnd->width;
        int h = mOglWnd->height;
        viewSys.SetDimensions(mView, 0, 0, w, h);

        if (mView->im)
            viewSys.SetZoom(mView, w / (float) mView->im->w,
                            h / (float) mView->im->h);

        DrawMinimap();

        Window::DisplayFunc();
    }

    virtual void MouseFunc(int msg, int but, int state, int x, int y)
    {
        if (but == 1)
        {
            ShowPreviewWindow();

            y = mOglWnd->height - y;
            x = mMapFunction->GetWidth() * x / mOglWnd->width;
            y = mMapFunction->GetHeight() * y / mOglWnd->height;
            ILOG_USER("Mouse previewing shot " << x <<"," << y <<" == " << mMapFunction->XYToShot(x,y));
            
            UpdatePreviewWindow(mMapFunction->XYToShot(x,y));
        }
        if (but == 0)
        {
            HidePreviewWindow();
        }
    }

    // convenience functions
    void
    RegisterTrail(ShotTrail *trail)
    {
        mTrails.push_back(trail);
    }

    void
    DrawMinimap()
    {
        Blank();
        for (int i=0; i<mTrails.size(); i++)
        {
            DrawTrail(mTrails[i]);
        }
        mOglIm->changed = 1;
    }

    void
    DrawTrail(ShotTrail *trail)
    {
        for (int i=0; i<trail->GetLength();i++)
        {
            SetPoint(trail->GetShot(i), trail->GetColor(i));
        }
    }

    // internal marking functions:

    Vec3Int32 GetPoint(int shot)
    {
        MapCoordPos p = mCoordMap[shot];
        Array2dVec3UInt8* ar =(Array2dVec3UInt8*)mOglIm->imageHandle;
        return ar->Value(p.x,p.y);
    }
    inline void
    SetPoint(int shot, Vec3Int32 color)
    {
        MapCoordPos p = mCoordMap[shot];
        Vec3Int32 ccolor = GetPoint(shot);
        // incorrect, but doable for now:
        //int c = p.count;
        SetPoint(p.x, p.y, color);
        //if (c == 1)
        //else
        //{
        //    SetPoint(p.x, p.y, Vec3Int32(
        //        (ccolor.X() * (c-1) + color.X()) / 256,
        //        (ccolor.Y() * (c-1) + color.Y()) / 256,
        //        (ccolor.Z() * (c-1) + color.Z()) / 256));
        //}
    }
   
    inline void
    SetPoint(int x, int y, Vec3Int32 color)
    {
        if (!mOglIm)
            return;
        Array2dVec3UInt8* ar =(Array2dVec3UInt8*)mOglIm->imageHandle;

        Vec3Int32 ccol = ar->Value(x,y);
        
        ar->SetValue(MergeCol(ccol,color), x, y);
    }

    inline Vec3Int32 MergeCol(Vec3Int32 ca, Vec3Int32 cb)
    {
        int r,g,b;
        if (ca.X() > cb.X())  r = ca.X(); else r = cb.X();
        if (ca.Y() > cb.Y())  g = ca.Y(); else g = cb.Y();
        if (ca.Z() > cb.Z())  b = ca.Z(); else b = cb.Z();
        return Vec3Int32(r,g,b);
    }

    void
    Blank()
    {
        if (!mOglIm)
            return;
        Array2dVec3UInt8* ar =(Array2dVec3UInt8*)mOglIm->imageHandle;
        for (int x=0;x<mOglIm->w;x++)
            for (int y=0;y<mOglIm->h;y++)
                ar->SetValue(Vec3Int32(20,20,20), x, y);
    }

    void
    EnablePreviewWindow(Core::Trec::ThreadSet *t)
    {
        mThreadSet = t;
        InitPreviewWindow();
        HidePreviewWindow();
    }

    void
    ShowPreviewWindow()
    {
        mPreviewWindow->SetVisible(true);
    }

    void
    HidePreviewWindow()
    {
        mPreviewWindow->SetVisible(false);
    }

protected:

    OGLIMAGE*
    InitOGLIMAGE(int imW, int imH)
    {
        mOglIm = oglSys.OglImage(GL_RGB, imW, imH);
        mOglIm->imDataFunc = MyOglImdataFunc;
        mOglIm->onDestroy = MyOglImdataDestroyFunc;
        Array2dVec3UInt8* ar =
            Core::Array::ArrayCreate<Array2dVec3UInt8>(imW, imH, 0, 0);
        mOglIm->imageHandle = ar;
        return mOglIm;
    }
   
    OGLIMAGE*
    CreateImageForShotID(int shotID)
    {
        OGLIMAGE *im;
        Array2dVec3UInt8* ar =
//            Core::Array::ArrayCreate<Array2dVec3UInt8>(100, 100, 0, 0);
            mThreadSet->GetImageByShotID(shotID); //-- TODO
        im = oglSys.OglImage(GL_RGB, ar->CW(), ar->CH());
        im->imDataFunc = MyOglImdataFunc;
        im->onDestroy = MyOglImdataDestroyFunc;        
        im->imageHandle = ar;
        return im;
    }

    void
    DoUpdateDispImage(OGLIMAGE* oglIm)
    {
        oglIm->changed = 1;
    }

    static void*
    MyOglImdataFunc(OGLIMAGE* oglIm)
    {
        // Obtain our 'im' stored as 'imageHandle'
        Array2dVec3UInt8* ar = (Array2dVec3UInt8 *) oglIm->imageHandle;

        // Set oglIm dimensions to our 'im' dimensions
        oglIm->w = ar->CW();
        oglIm->h = ar->CH();
        oglIm->changed = 0;
        return (void *) ar->CPB(0, 0); // Pointer to the image pixels
    }

    static void
    MyOglImdataDestroyFunc(OGLIMAGE* oglIm)
    {
        if (!oglIm)
            return;
        Array2dVec3UInt8* ar = (Array2dVec3UInt8 *) oglIm->imageHandle;
        if (ar)
            delete ar;
    }


private:

    void
    UpdatePreviewWindow(int shot)
    {   
        if (shot >= 0) {
            OGLIMAGE *i = CreateImageForShotID(shot);
            mPreviewWindow->SetImage(i);
            oglSys.ReleaseOglImage(i);
        }
    }

    void
    InitPreviewWindow()
    {
        if (mPreviewWindow)
            return;

        // TODO: hack, hard coded coords, fix later!
        mPreviewWindow = new OglGui::WindowView2D(mParentWindow,
                                                  mParentWindow->W() - 420,
                                                  mParentWindow->H() - 220,
                                                  200,200,0);
    }

    void
    Init(MapFunction *map, int screenwidth, int screenheight, Window *parent)
    {
        // init shot to minimap table:
        ILOG_DEBUG("initializing map...");

        mMapFunction = map;

        int width = map->GetWidth();
        int height = map->GetHeight();

        //int counts[width][height];
        Core::Array::Array2dScalarInt32* counts =
            Core::Array::ArrayCreate<Core::Array::Array2dScalarInt32>(width, height, 0, 0);

        int x, y;

        // clear counters:
        for (x=0;x<width;x++)
            for (y=0;y<height;y++)
                //counts[x][y] = 0;
                counts->SetValue(0, x, y);

        // map shot -> x,y and count nr of shots per x,y pos
        for (int i = 0; i < map->GetNrShots(); i++)
        {
            map->ShotToXY(i, &x, &y);
            //counts[x][y] = counts[x][y] + 1;
            counts->SetValue(counts->Val(x, y) + 1, x, y);
            MapCoordPos p;
            p.x = x;
            p.y = y;
            p.count = 0;
            mCoordMap[i] = p;
        }

        // update map so that every shot knows how many other shots share x,y
        for (int i = 0; i < map->GetNrShots(); i++)
        {
            //mCoordMap[i].count = counts[mCoordMap[i].x][mCoordMap[i].y];
            mCoordMap[i].count = counts->Val(mCoordMap[i].x, mCoordMap[i].y);
        }
        ILOG_DEBUG("map initialized.");


        // init visualization:
        InitOGLIMAGE(width, height);

        mView = viewSys.View2D(mOglWnd, mOglIm, 0, 0, screenwidth, screenheight);
        viewSys.SetTags(mView, visibleTag);

        mParentWindow = parent;
        mPreviewWindow = 0;
        mThreadSet = 0;

        Blank();
    }


    // map:
    std::map <int, MapCoordPos> mCoordMap;
    std::vector<ShotTrail*> mTrails;
    MapFunction *mMapFunction;

    // visualization:
    OGLIMAGE *mOglIm;
    OGLVIEW *mView;

    Window *mParentWindow;

    OglGui::WindowView2D*   mPreviewWindow;

    // hack to get images for showing in preview window:
    Core::Trec::ThreadSet *mThreadSet;

    ILOG_VAR_DEC;
};

ILOG_VAR_INIT(VideoMinimap, Visualization);


}
}

#endif

---