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

---

SurveillanceMap.h

Go to the documentation of this file.

/*******************************************************************************
 *
 * Application: Surveillance Dashboard (MultimediaN project 6)
 *
 * Primary author(s): Richard van Balen
 *                  : 
 *                  : 
 ******************************************************************************/
/*
12345678901234567890123456789012345678901234567890123456789012345678901234567890
*/

#ifndef Impala_Application_SDash_SurveillanceMap_h
#define Impala_Application_SDash_SurveillanceMap_h

#include <vector>
#include <string>
#include <ostream>
#include <strstream>

#ifndef Impala_Application_SDash_SurveillanceMapListener_h
#include "Application/sdash/SurveillanceMapListener.h"
#endif

#ifndef OglGui_Button_h
#include "OglGui/Button.h"
#endif

#ifndef OglGui_WindowView2D
#include "OglGui/WindowView2D.h"
#endif

#ifndef OglGui_StaticText_h
#include "OglGui/StaticText.h"
#endif

#include "Link/OGL/OGLGraphics.h"

namespace Impala {
namespace Application {
namespace SDash {

// Sander: In deze class kun je het tekenen van een track implementeren
// Ik wil het ook wel doen. Je zegt het maar.
class SurveillanceMap : public OglGui::WindowView2D,
                        public OglGui::ButtonListener,
                        public OglGui::WindowListener
{
typedef OglGui::WindowView2D     WindowView2D;
typedef OglGui::ButtonListener   ButtonListener;
typedef OglGui::Window           Window;
typedef OglGui::Button           Button;
typedef OglGui::StaticText       StaticText;

public:

    SurveillanceMap(int x,int y,int w,int h, OGLIMAGE* im=0) :
        WindowView2D(x, y, w, h, im)
        {
                Init(w, h);
        }

    SurveillanceMap(Window *parent, int w, int h, OGLIMAGE* im=0) :
        WindowView2D(parent, w, h, im)
        {
                Init(w, h);
        }

    SurveillanceMap(Window *parent,int x,int y,int w,int h, OGLIMAGE* im=0) :
        WindowView2D(parent, x, y, w, h, im)
        {
                Init(w, h);
        }

    void SetSurveillanceMapListener(SurveillanceMapListener* li, void* userData=0)
    {
        mListener = li;
        mListenerData = userData;
    }

    /*
    virtual void ButtonSelectionEvent(Button *src, int userData)
    {
        for (int i=0; i<mButtons.size(); i++)
            mButtons[i]->SetBackground(mButtons[i]==src ? oglRED : 0);
        mCurrent = GetButtonId(src);
        if (mListener != 0)
            mListener->ButtonSelectionEvent(this, mCurrent, mListenerData);
    }
    */
    virtual void ButtonSelectionEvent(Button *src, void* userData)
    {
        int mCurrent = GetButtonId(src);
        SetSelectedButton(mCurrent);
        if (mListener != 0)
            mListener->ButtonSelectionEvent(this, mCurrent, mListenerData);
    }

    // Reacts on mouse enter and leave of the buttons
    virtual void
    WindowMouseEvent(Window *src, int msg, int but, int state,
                     int x, int y, void* userData )
    {
        if (mShowTrack)
            return;
        int id = GetButtonId((Button*)src);
        if (msg == oglMouseEnter)
            mStreetLabels[id]->SetVisible(true);
        if (msg == oglMouseLeave)
            mStreetLabels[id]->SetVisible(false);
    }

    Button* CreateButton(int x, int y, strconst title)
    {
        Button* btn = new Button(this, x-12, y-12, 24, 24, title);

        btn->SetBorderType(-1);
        btn->SetBorderBackground(oglBLUE);
        btn->SetForeground(oglWHITE);
        btn->SetTextShadowed(false);
        btn->SetDoStateFeedback(false);
        btn->SetButtonListener(this);
        btn->SetWindowListener(this);

        int index = mButtons.size();
        int labelPos = mLabelPositions[index];
        int xL, yL;
        int wL = 200;
        int hL = 20;

        if (labelPos == 0)
        {
            xL = x + 8;
            yL = y + 8;
        }
        else if (labelPos == 1)
        {
            xL = x + 8;
            yL = y - hL - 8;
        }
        else if (labelPos == 2)
        {
            xL = x - wL - 8;
            yL = y - hL - 8;
        }
        else 
        {
            xL = x - wL - 8;
            yL = y + 8;
        }

        StaticText* label = new StaticText(this, xL, yL, wL, hL, "-", false);
        label->SetBorderType(BEV_RIDGE);
        label->SetBorderBackground(0x80ff002f);
        label->SetForeground(oglWHITE);
        label->SetTextShadowed(false);
        label->SetVisible(false);

        mButtons.push_back(btn);
        mLabels.push_back(label);

        wL = 200;
        label = new StaticText(this, xL, yL, wL, hL, "-");
        label->SetText(mLocations[mButtons.size()-1]);
        label->SetBorderType(BEV_RIDGE);
        label->SetBorderBackground(0x80ff002f);
        label->SetForeground(oglWHITE);
        label->SetTextShadowed(false);
        label->SetVisible(false);
        mStreetLabels.push_back(label);

        return btn;
    }

    bool    ShowTrack()         { return mShowTrack; }
    int     NrOfButtons()       { return mButtons.size(); }
    int     GetActiveButtonId() { return mCurrent; }
    Button* GetActiveButton()   { return GetButton(mCurrent); }

    int GetButtonId(Button* btn)
    {
        for (int i=0; i<mButtons.size(); i++)
            if (btn == mButtons[i])
                return i;
        return -1;
    }
    Button* GetButton(int id)
    {
        if (id < 0 || id >= mButtons.size())
            return 0;
        return mButtons[id];
    }

    void SetSelectedButton(int id)
    {
        for (int i=0; i<mButtons.size(); i++)
            mButtons[i]->SetBackground((i==id) ? oglRED : 0);
        UpdateScene();
    }

    void SelectButton(int id)
    {
        Button* btn = GetButton(id);
        if (!btn)
            return;
        ButtonSelectionEvent(btn, 0);
//        UpdateScene();
    }

    void RemoveButtons()
    {
        for (int i=0 ; i<mButtons.size() ; i++)
            delete mButtons[i];
        mButtons.clear();
        mCurrent = -1;
    }

    std::string LocationString(int id)
    {
        return mLocations[id];
    }

    virtual void DisplayFunc()
    {
        OglGui::WindowView2D::DisplayFunc();
        DrawTrack();
    }

    void DrawTrack( )
    {
        if (!mShowTrack)
            return;

        glPushMatrix(); // Push modelview onto the matrix stack. 
            OGC         myOGC;
            OGCSave( &myOGC ); // Save present OpenGL and theOGC settings in myOGC

        int bInfo[3];
        oglSys.StartBlend(bInfo);

            SetLineWidth( 8.0f );
            SetSolidLineColor( oglRED );

        for (int i = 1; i < mTrackSize; i++)
        {
            Button* fromBtn = mButtons[mTrackVideoIds[i-1]];
            Button* toBtn = mButtons[mTrackVideoIds[i]];
            float fromX = (float) fromBtn->X() + 12;
            float fromY = (float) fromBtn->Y() + 12;
            float toX = (float) toBtn->X() + 12;
            float toY = (float) toBtn->Y() + 12;
                DrawColLine(fromX, fromY, toX, toY, 0x60ff6060, oglRED);
        }

        oglSys.EndBlend(bInfo);
        
            OGCRestore( &myOGC ); // Restore theOGC
            glPopMatrix(); // Restore modelview matrix
    }

    void SetTrack(std::vector<int> videoIds, std::vector<int> timesInSec)
    {
        ClearTrack();

        mTrackSize = videoIds.size();
        mTrackVideoIds = videoIds;

        for (int i = 0; i < mTrackSize; i++)
        {
            int time0 = clock();

            int hours = timesInSec[i] / 3600;
            int remainingSec = timesInSec[i] % 3600;
            int minutes = remainingSec / 60;
            int sec = remainingSec % 60;

            char buf[100];
            sprintf(buf, "%02d:%02d:%02d", hours, minutes, sec);

            std::ostrstream fullDescr;
            //fullDescr << hours << ':' << minutes << ':' << sec;
            fullDescr << buf;
            fullDescr << ' ' << mLocations[videoIds[i]] << std::ends;
            std::string message = std::string(fullDescr.str());

            mLabels[videoIds[i]]->SetText(message);
            mLabels[videoIds[i]]->SetVisible(true);

            std::cout << (clock() - time0) / CLOCKS_PER_SEC << " sec.s for setting track" << std::endl;
        }

        mShowTrack = mTrackSize > 0;

        UpdateScene(); // refresh window
    }

    void ClearTrack()
    {
        mShowTrack = false;

        for (int i = 0; i < mLabels.size(); i++)
            mLabels[i]->SetVisible(false);

        mTrackVideoIds.clear();
        mTrackSize = 0;

        UpdateScene(); // refresh window
    }

    const std::vector<const std::string* const> GetCamAddresses(const std::vector<int>& cams)
    {
        std::vector<const std::string* const> addresses;
        for (int i = 0; i < cams.size(); i++)
            addresses.push_back(&mLocations[cams[i]]);
        return addresses;
    }

private:

    SurveillanceMapListener*    mListener;
    void*                       mListenerData;
    int                         mCurrent;
    int mDisplayCounter;

    std::vector<Button*> mButtons;
    std::vector<StaticText*> mLabels;
    std::vector<StaticText*> mStreetLabels;
    std::vector<int> mLabelPositions; 
    std::vector<std::string> mLocations;
    bool mShowTrack;
    int mTrackSize;
    std::vector<int> mTrackVideoIds;

        void Init(int w, int h)
        {
        mListener = 0;
        mCurrent = -1;
        mView->texturing = 0;
        mDisplayCounter = 0;
        mShowTrack = false;
        mTrackSize = 0;

        mLocations.push_back("Keileweg zuid");
        mLocations.push_back("Keileweg noord");
        mLocations.push_back("Benjamin Franklinstraat");
        mLocations.push_back("Van Helmontstraat");
        mLocations.push_back("Ohmstraat");
        mLocations.push_back("Vierhavenstraat zuid");
        mLocations.push_back("Marconiplein zuid");
        mLocations.push_back("Marconiplein noord");
        mLocations.push_back("Marconiplein/Math.dijk");
        mLocations.push_back("Mathenesserdijk");
        mLocations.push_back("Mathenesserweg");
        mLocations.push_back("Vierhavenstraat noord");

        mLocations.push_back("Station Marconiplein #1");
        mLocations.push_back("Station Marconiplein #2");
        mLocations.push_back("Station Marconiplein #3");

        // 0 = re boven, 1 = re onder, 2 = li onder, 3 = li boven
        mLabelPositions.push_back(3);
        mLabelPositions.push_back(3);
        mLabelPositions.push_back(0);
        mLabelPositions.push_back(3);
        mLabelPositions.push_back(2);
        mLabelPositions.push_back(2);
        mLabelPositions.push_back(2);
        mLabelPositions.push_back(3);
        mLabelPositions.push_back(0);
        mLabelPositions.push_back(1);
        mLabelPositions.push_back(1);
        mLabelPositions.push_back(0);

        mLabelPositions.push_back(3);
        mLabelPositions.push_back(3);
        mLabelPositions.push_back(3);
        }
};

}
}
}

#endif

---