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

---

SurveillanceApp.cpp

Go to the documentation of this file.

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

// If the monitors try to read the next frame all at the
// same time, the display could become jerky. The next define
// allows to test if this is the case.
// Put into comment when not testing
//#define PRINT_JPG_READ

// Experimental: Probably to be removed
// Allows to switch between 3 monitors and 12 monitors
// Put into comment to prevent the Show all monitor option
#define ALL_MONITORS

#include <string>
#include <map>
#include <vector>

#include "OglGui/Button.h"
#include "OglGui/Tabs.h"
#include "OglGui/GroupBox.h"
#include "OglGui/CheckBox.h"
#include "OglGui/RadioGroup.h"
#include "OglGui/FramesPerSecond.h"
#include "OglGui/WindowView2D.h"
#include "OglGui/ViewStrip.h"
#include "OglGui/AlertTimeLine.h"

#include "Visualization/Video.h"
#include "Visualization/VideoJpgPlayer.h"
#include "Visualization/VideoJpgPlayerControl.h"
//#include "Visualization/RgbOglImage.h"

#include "Basis/CmdOptions.h"

#include "Application/sdash/SurveillanceMap.h"
#include "Application/sdash/CameraEventListPane.h"
#include "Application/sdash/VideoJpgCamera.h"
#include "Application/sdash/VideoPlayerListener.h"
#include "Application/sdash/VideoPlayerView.h"
#include "Application/sdash/RegionsOfInterestInfo.h"
#include "Application/sdash/RegionsOfInterestCorrelation.h"
#include "Application/sdash/AlertWindow.h"
#include "Application/sdash/RoiLoader.h"
#include "Application/sdash/IdentificationPane.h"
#include "Application/sdash/RoiInfo.h"
#include "Application/sdash/GuiEventListener.h"
#include "Application/sdash/MonitorSelector.h"
#include "Application/sdash/PoliceMan.h"
#include "Application/sdash/ActivityReader.h"
#include "Application/sdash/TimeSlider.h"
#include "Application/sdash/ApplicationEnding.h"
#include "Application/sdash/CameraMovementReader.h"

#include "Application/sdash/LogoAnimation.h"


#include "OglGui/OglLib.cpp"
#include "Link/ImpalaLib.cpp"

namespace Impala {
namespace Application {
namespace SDash {

static const int NR_OF_CAMERAS_STREET = 12;
static const int NR_OF_CAMERAS_STATION = 3;
static const int NR_OF_CAMERAS = NR_OF_CAMERAS_STREET + NR_OF_CAMERAS_STATION;

// video ID's follow from position in this list:
// (ID's must be compatible with Thang's metadata)
static const char *VIDEO_NAMES_STREET[] = {
            "cam8.01",
            "cam8.02",
            "cam8.03",
            "cam8.04",
            "cam8.05",
            "cam8.06",
            "cam8.07",
            "cam9.01",
            "cam9.02",
            "cam9.03",
            "cam9.08",
            "cam9.09"
};

static const int NR_OF_POLICEMEN = 6;

static const char *POLICE_TEXTS[] = {
            "3063: Jan Staal\nwijkagent; auto",
            "0233: Ruud de Jong\nstadswacht; te voet",
            "8956: Brenda Sikkens\nnoodhulp; te voet",
            "3508: Ibrahim Veder\nwijkagent; auto",
            "7354: Dennis Zwiers\nwijkagent; fiets",
            "2977: Liesbeth Verwijs\nwijkagent; fiets"
};

static const char *MAILTO_TEXTS[] = {
            "Jan Staal, wijkagent, auto",
            "Ruud de Jong, stadswacht, te voet",
            "Brenda Sikkens, noodhulp, te voet",
            "Ibrahim Veder, wijkagent, auto",
            "Dennis Zwiers, wijkagent, fiets",
            "Liesbeth Verwijs, wijkagent, fiets"
};

static const int POLICE_POSITIONS[] = {
     484,342,1,
     724,746,1,
     146,528,0,
     438,673,0,
     936,482,0,
     954,482,0
};


//static const float TIMES_PER_FRAME[] = {
//    0.3875f,
//    0.559f,
//    0.3705f,
//    0.3732f,
//    0.378f,
//    0.384f,
//    0.3932f,
//    0.4525f,
//    0.4525f,
//    0.4525f,
//    0.453f,
//    0.453f,
//    1.0f / ActivityReader::FRAME_RATE,
//    1.0f / ActivityReader::FRAME_RATE,
//    1.0f / ActivityReader::FRAME_RATE
//};

// Optimized for 60 minutes video, 30 minutes virtual offset
static const float TIMES_PER_FRAME[] = {
    0.3892f,
    0.559f,
    0.372f,
    0.374f,
    0.379f,
    0.385f,
    0.3932f,
    0.452f,
    0.452f,
    0.452f,
    0.4528f,
    0.4524f,
    1.0f / ActivityReader::FRAME_RATE,
    1.0f / ActivityReader::FRAME_RATE,
    1.0f / ActivityReader::FRAME_RATE
};

// frame times first 12 video's as 3600 / <nr of frames>:
    //0.3894f,
    //0.55814f,
    //0.37098f,
    //0.37352f,
    //0.37863f,
    //0.38457f,
    //0.39233f,
    //0.45317f,
    //0.45312f,
    //0.45260f,
    //0.45306f,
    //0.45266f,

static const int MAX_FRAMES[] = {
#ifdef RICHARD
    4623,
    3221,
    4842,
    4811,
    4748,
    4674,
    4575,
    3983,
    3983,
    3983,
    3976,
    3979
#else
    9245,
    6450,
    9704,
    9638,
    9508,
    9361,
    9176,
    7944,
    7945,
    7954,
    7946,
    7953
#endif
}; // NOTE perron cameras niet in deze lijst.


static const std::string    ROI_INFO_FILE  = "boxes-b.bin";
static const std::string    ROI_CORR_FILE  = "boxes.corr";

//static const int VIRTUAL_TIME_OFFSET  = 27 * 60;
//static const int VIRTUAL_TIME_OFFSET  = 20 * 60;
#ifdef RICHARD
static const int VIRTUAL_TIME_OFFSET  = 15 * 60;
#else
static const int VIRTUAL_TIME_OFFSET  = 30 * 60;
#endif
//static const int VIRTUAL_TIME_OFFSET    = 10 * 60;
//static const int VIRTUAL_TIME_OFFSET  = 5 * 60;

#ifdef RICHARD
static const int VIDEO_DURATION         = 30 * 60;
#else
static const int VIDEO_DURATION         = 60 * 60;
#endif
static const int RESTART_TIME           = VIDEO_DURATION - 20;
//static const int RESTART_TIME           = VIRTUAL_TIME_OFFSET + 20;

static std::string gIpAddress = "";

static std::string gDataRoot = "";
static std::string gVideoPathThang = "";
static std::string gRoiPath = "";
static std::string gVideoPathMichael = "";
static std::string gXmlPathMichael = "";
static std::string gCamMovementInfoPath = "";

using namespace OglGui;

//
// Main application class
//
class SurveillanceApp : public Window,
                        public SurveillanceMapListener,
                        public MonitorSelectorListener,
                        public ButtonListener,
                        public PoliceManListener,
                        public GuiEventListener,
                        public WindowListener,
                        public TimeSliderListener
{

    typedef Visualization::VideoJpgPlayer            VideoJpgPlayer;
    typedef Visualization::VideoJpgPlayerControl     VideoJpgPlayerControl;
    typedef Visualization::VideoJpgPlayerListener    VideoJpgPlayerListener;
    typedef Core::Array::Array2dVec3UInt8            Array2dVec3UInt8;

public:

    SurveillanceApp(int width, int height) : Window(0, 0, width, height)
        {
        SetupVideoData(mVideos);

        const int nrOfVideosToCollectRoisFor = NR_OF_CAMERAS_STREET;
        const std::string roiFileName = gRoiPath + ROI_INFO_FILE;
        //const int maxMinutes = 32;// 32 minutes of roi's for 30 minutes of video

        mDetectedPersons =
            new RegionsOfInterestInfo(roiFileName,NR_OF_CAMERAS_STREET,MAX_FRAMES,true);

        mSimilarPersons =
            new RegionsOfInterestCorrelation(gRoiPath + ROI_CORR_FILE, *mDetectedPersons);

        ScheduleCamEvents(mCamEventSchedule);

        GetOGLWND()->topTitle =
            "MultimediaN - Surveillance Dashboard";

        mInspectVideoId = 0;
        //mMaxVideoFrame = 4500;

        SetBackground(oglGUI_BG);
        BuildSecondScreenGUI();
        BuildGUI(width, height);

        mMonitorSelector = new MonitorSelector(mSurveillanceMap,120,40,3);
        mMonitorSelector->SetVisible(false);

        mSurveillanceMap->SetSurveillanceMapListener(this);
        mSurveillanceMap->SetWindowListener(this);

        for (int i = 0; i < NR_OF_POLICEMEN; i++)
        {
            PoliceMan* policeMan =
                new PoliceMan(mSurveillanceMap, POLICE_POSITIONS[i*3],
                              POLICE_POSITIONS[i*3+1],20,40,
                              POLICE_TEXTS[i], POLICE_POSITIONS[i*3+2] ? oglGREEN : 0xffff8080);
                              //POLICE_TEXTS[i], POLICE_POSITIONS[i*3+2] ? oglGREEN : oglGREY);
            policeMan->ScaleTo(mSurveillanceMap,NoHeight|NoWidth);
            policeMan->SetPoliceManListener(this,(void*)i);
        }

        // Just for fun: MultiMedian logos in lower right corner
        // When pressed shows the multimedian screensaver animation
        // drawn transparently over the entire interface
        // When running clicking the mouse anywhere hides the animation
        // Clicking the logos toggles the animation visibility
        new LogoAnimation(this, width, height);

        mCamEventSchedulePosition = mCamEventSchedule.begin();

        mApplicationEnding =
            new ApplicationEnding(this, "End of demo. Surveillance Dashboard restarting in:");

        if (Valid())
            Start(); // start OGL
    }

    ~SurveillanceApp()
        {
        printf("SurveillanceApp destructor\n");
        CleanUp();
    }

    void CleanUp()
    {
        printf("Cleaning Up\n");
        delete mDetectedPersons;
        delete mSimilarPersons;
    }

    void ShowEvent(const CameraEvent& camEvent)
    {
        //mTimeLine->AddAlert(camEvent.CameraId(), camEvent.PreferredBackColor(), (int) &camEvent);
        mTimeLine->AddAlert(camEvent.CameraId(), camEvent.PreferredBackColor(), (void*) &camEvent, camEvent.Seconds());
        mCameraEventListPane->EventList()->AddCameraEvent(&camEvent);
    }

    void HandleSubmitButtonState()
    {
        bool hasPositives = mIdPane->Positives()->GetOGLWND()->objectList!=0;
        if (!hasPositives)
            mSubmitButton->SetState(0);
        else if ((mSubmitButton->GetState() && mAlertWindow->GetVisible()) ||
            (!mAlertWindow->GetVisible() && !mSubmitButton->GetState()))
        {
            mSubmitButton->SetState(!mAlertWindow->GetVisible());
        }
    }

    virtual void DisplayFunc()
    {
        static bool initialized = false;

        // Here events should be generated based on the current time 
        long startTime = mTimeLine->GetStartTime();
        long currentTime = mTimeLine->GetCurrentTime();
        int runTime = (currentTime - startTime);

        mVideoPlayer->SetShowMaxFrame(runTime/TIMES_PER_FRAME[mInspectVideoId]);
        mVideoTimeSlider->TimeSpan(runTime);
        //mVideoTimeSlider->TimeSpan(30*60);
        long timePast = mVideoPlayer->GetTimePast();
        mVideoTimeSlider->CurrentTime(startTime+timePast);

        // SK: no longer random events
        //if (!initialized)
        //{
        //    if (runTime >= 1)
        //        initialized = true;
        //}
        //else if (ABSRND(2000)>1997)
        //{
        //    int id = 1 + ABSRND(NR_OF_CAMERAS);
        //    int type = 1 + ABSRND(4);
        //    CameraEvent* cameraEvent =
        //        new CameraEvent(id,type,currentTime,"random");
        //    ShowEvent(*cameraEvent);
        //}

        // show scheduled events; note that the map is ordered by scheduled time (secs)
        while (mCamEventSchedulePosition != mCamEventSchedule.end())
        {
            const int nextEventTime = mCamEventSchedulePosition->first;
            if (nextEventTime > runTime)
                break;
            std::vector<CameraEvent>& scheduledEvents = mCamEventSchedulePosition->second;
            const int nrOfEvents = scheduledEvents.size();
            for (int i = 0; i < nrOfEvents; i++)
            {
                CameraEvent& camEvent = scheduledEvents[i];
                const long virtualSecs = startTime + nextEventTime;
                camEvent.SetSeconds(virtualSecs);
                ShowEvent(camEvent);
            }
            mCamEventSchedulePosition++;
        }

        HandleSubmitButtonState();
        Window::DisplayFunc();

static int cnt = 0;
#ifdef PRINT_JPG_READ
printf("FR:%d\n", cnt++);
#endif

        if (!mExitButton->GetVisible() && runTime >= RESTART_TIME)
            mApplicationEnding->StartApplicationEnding();
    }

    void BuildGUI(int w, int h)
        {
        int monitorPaneY = h-332;
        //BuildTimeLinePane(this,8,monitorPaneY-160,w-16,152);
        BuildTimeLinePane(this,412,monitorPaneY-232,w-414,228);
        mCameraEventListPane = new CameraEventListPane(this,2,monitorPaneY-232,406,228);
        SetAsBox(mCameraEventListPane);
        mCameraEventListPane->ScaleTo(this);
        BuildMonitorPane(this,2,monitorPaneY,w-4,330);
        BuildInspectionPane(this,2,2,w-4,monitorPaneY-240);
#ifdef ALL_MONITORS
mAllCamerasPane = BuildMonitorAll(this,8,monitorPaneY,w-16,330+24);
mAllCamerasPane->SetToFrontOnMouseDown(false);
mAllCamerasPane->SetVisible(false);
#endif

        mTimeLine->SetTime(14*3600 + 14*60 + 40, VIRTUAL_TIME_OFFSET);
        for(int i=0;i<3;i++)
            mVideoCameras[i]->Play(VIRTUAL_TIME_OFFSET);
    }

// Utilities
    void SetAsBox(Window *w)
    {
        w->SetRoundness(0,0,0,0);
        w->SetBorderType(BEV_ETCHED);
        w->SetBorderFillShaded(DEEP_SHADE_UP);
    }

// Implementation of monitor pane
    void BuildMonitorPane(Window* wnd, int x, int y, int w, int h)
    {
        Window* pane = new Window(wnd, x, y, w, h);

        for (int i=0; i<3; i++)
        {
            int vX = i*w/3, vY = 0;
            int vW = w/3, vH = h;
            int videoId = i;// + NR_OF_CAMERAS_STREET;
            int camId = videoId + 1;

            mVideoCameras[i] = new VideoJpgCamera(pane,vX,vY,vW,vH, mVideos[videoId]);
            mVideoCameras[i]->Play(VIRTUAL_TIME_OFFSET);
            mVideoCameras[i]->SetWindowListener(this);
            mVideoCamerasVideoId[i] = videoId;

            mCameraTexts[i] = new StaticText(mVideoCameras[i],58,vH-38,180,20,
                                             MonitorString(camId-1),false,true);
            mCameraTexts[i]->SetForeground(0xffffff00); // Yellow
            mCameraTexts[i]->SetShadowColor(oglBLACK);
            mCameraTexts[i]->SetBorderType(-1);
            mCameraTexts[i]->SetBorderFillShaded(2);

            mCameraTexts[i]->SetAlign(oglLeftAlign, oglCenterAlign);
            Sleep(50);
        }
        pane->ScaleTo(wnd);
        pane->ScaleChildren(0,1);
        mMonitorPane = pane;
    }

    char* MonitorString(int camId)
    {
        static char    buf[100];
        sprintf(buf, "[%d] %s", camId+1,
                mSurveillanceMap->LocationString(camId).c_str());
        return &buf[0];
    }

    TitledWindow* BuildMonitorAll(Window* wnd, int x, int y, int w, int h)
    {
        TitledWindow*   titleWnd = new TitledWindow(wnd,x,y,w,h,"Monitor all");
        Window*         pane  = new Window(titleWnd,0,0,200,200);

        titleWnd->SetContentPane(pane);

        w = pane->W(), h = pane->H();
        for (int i=0;i<12;i++)
        {
            int vX = (i%6)*w/6, vY = (1-i/6)*h/2;
            int vW = w/6, vH = h/2;
            int camId = i + 1;
            int videoId = i;

            VideoJpgCamera* vc =
                new VideoJpgCamera(pane,vX,vY,vW,vH, mVideos[videoId]);

            mAllCamerasVideos[i] = vc;

            vc->Play(VIRTUAL_TIME_OFFSET);
            vc->SetWindowListener(this,(void*)(i+1));

            StaticText* camTxt =
                new StaticText(vc,4,4,200,20,MonitorString(i),false,true);
            //camTxt->SetForeground(oglWHITE);
            camTxt->SetForeground(0xffffff00); // Yellow
            camTxt->SetShadowColor(oglBLACK);
            camTxt->SetAlign(oglLeftAlign, oglCenterAlign);
            Sleep(10);
        }
        pane->ScaleChildren();
        return titleWnd;
    }

    void BuildTimeLinePane(Window* wnd, int x, int y, int w, int h)
    {
        GroupBox* timeLinePane = new GroupBox(wnd,x,y,w,h,"Timeline" );
        SetAsBox(timeLinePane);
        timeLinePane->ScaleTo(wnd);
        mFramesPerSecond = new FramesPerSecond(timeLinePane,4,h-50,70,24);
        mFramesPerSecond->ConnectTo(timeLinePane,L2L|B2T|R2L|T2T);

        mTimeLine = new AlertTimeLine(timeLinePane,20,4,w-40,h-8);
        //mTimeLine->SetStartTime(14*3600 + 14*60 + 40);
        mTimeLine->SetTime(14*3600 + 14*60 + 40, VIRTUAL_TIME_OFFSET);
        mTimeLine->SetTimeSpan(900);
        mTimeLine->SetOlderThanText("older than 15 min");
        mTimeLine->OlderThanButton()->SetButtonListener(this);
        mTimeLine->ScaleTo(wnd);
    }

// Implementation of InspectTrackAlertPane
// (Note: Could also be implemented as separate class)
    void BuildInspectionPane(Window *wnd, int x, int y, int w, int h)
    {
        mInspectionPane = new Window(wnd,x,y,w,h);
        Window* pane = mInspectionPane;
        pane->ScaleTo(wnd);

        // The inspect videoplayer part
        GroupBox* gB = new GroupBox(pane,0,0,406,h,"Event playback");
        SetAsBox(gB);

        mVideoPlayer = new VideoJpgPlayer(gB,6,gB->H()-324,392,320, mVideos[0]);
        mVideoPlayer->SetVisible(false);

        mVideoPlayerCamText = new StaticText(mVideoPlayer,58,mVideoPlayer->H()-32,
                                             180, 20, "", false, true);
        mVideoPlayerCamText->SetForeground(0xffffff00); // Yellow
        mVideoPlayerCamText->SetShadowColor(oglBLACK);
        mVideoPlayerCamText->SetAlign(oglLeftAlign, oglCenterAlign);
        mVideoPlayerCamText->SetBorderType(-1);
        mVideoPlayerCamText->SetBorderFillShaded(2);

        mVideoTimeSlider =
            new TimeSlider(gB,2,32,gB->W()-4,46,14*3600+14*60+40,15*60);
        mVideoTimeSlider->SetTimeSliderListener(this);

        mVideoPlayerControl =
            new VideoJpgPlayerControl(gB,4,4,gB->W()-8,28,mVideoPlayer);
        mVideoPlayerControl->SetBorderType(3);

        for (int i=1; i<8; i++)
        {
            Button* btn = mVideoPlayerControl->GetButton(i);
            btn->SetRoundness(0,0,0,0);
            btn->SetBorderType(BEV_ETCHED);
        }
        gB->ScaleChildren(0,1);

        // Instantiate our class that allows us to be involved with the
        // OnImViewer interface (OnPreDrawView,OnDrawView, OnMouse...)
        // of the OGLVIEW* used in the video player.
        // This object is passed as userData to the videoPlayerListener
        mVideoPlayerView = new VideoPlayerView(mVideoPlayer->OglView());

        mVideoPlayerListener = new VideoPlayerListener(mVideos, *mDetectedPersons);
        mVideoPlayer->SetVideoJpgPlayerListener(mVideoPlayerListener,
                                                (void*)mVideoPlayerView);

        mCameraEventListPane->EventList()->SetButtonListener(this,(void*) mVideoPlayer);

        mTimeLine->SetAlertTimeLineListener(mCameraEventListPane, (void*)1);

        int gBX = gB->X()+gB->W()+4;

        gB = new GroupBox(pane,gBX,h-182,72,182,"Inspect");
        mSubjectWindow = new WindowView2D(gB, 4, 34, 64, 128);
        // This solves the problem of scewed drawing for images with un-even width
        mSubjectWindow->GetOglView()->texturing = 0;
        mSimilarsButton = new Button(gB,4,4,64,26,"Search",BEV_ETCHED,true);
        //new Button(gB,4,4,70,24,"Clear",BEV_ETCHED,true);
        SetAsBox(gB);

        mVideoPlayerView->SubjectWindow(mSubjectWindow, gRoiPath);
        mSimilarsButton->SetButtonListener(this);

        gB->ScaleChildren();

        gBX+=76;
        //mIdPane = new IdentificationPane(gRoiPath, NR_OF_CAMERAS_STREET, pane,gBX,52,w-gBX,h-52,"");
        mIdPane = new IdentificationPane(mVideos, gRoiPath, pane,gBX,52,w-gBX,h-52,"");
        mIdPane->mRoiInfo = mDetectedPersons;
        mIdPane->mRoiCorrelations = mSimilarPersons;
        //mIdPane->TimesPerFrame(&TIMES_PER_FRAME[0]);
        SetAsBox(mIdPane);
        SetAsBox(mIdPane->Similars());
        SetAsBox(mIdPane->Positives());
        mIdPane->SetGuiEventListener(this);


        int btnW        = 110;
        int btnSpace    = 8;
        mShowTrackButton = new Button(pane,gBX,12,btnW,32,
                                      "Suggest track", BEV_ETCHED,true);
        mShowTrackButton->SetButtonListener(this);
        mHideTrackButton = new Button(pane,gBX+btnW+btnSpace,12,btnW,32,
                                      "Clear track", BEV_ETCHED,true);
        mHideTrackButton->SetButtonListener(this);

        mSubmitButton = new Button(pane,gBX+2*(btnW+btnSpace),12,btnW,32,
                                   "Alert personnel",BEV_ETCHED,true);
        SubmitButtonListener* submitListener = new SubmitButtonListener(this);
        mSubmitButton->SetButtonListener(submitListener, (void*) mIdPane);

#ifdef ALL_MONITORS
mAllCamerasButton = new Button(pane,gBX+3*(btnW+btnSpace),12,btnW,32,
                                "All cameras", BEV_ETCHED,true);
mAllCamerasButton->SetButtonListener(this);
#endif

        mExitButton = new Button(pane,gBX+10+4*(btnW+btnSpace),12,60,32,
                                 "EXIT",BEV_ETCHED,true);
        mExitButton->SetVisible(false);
        mExitButton->SetButtonListener(this);

        pane->ScaleChildren();
        // See lengthy explanation in BuildSecondScreen below
        pane->SetAllowChildScaling(false);

        mAlertWindow = new AlertWindow(this, gIpAddress);
        for (int i = 0; i < NR_OF_POLICEMEN; i++)
            mAlertWindow->AddMailTo(MAILTO_TEXTS[i]);
        mAlertWindow->SetVisible(false);
        submitListener->SetAlertWindow(mAlertWindow);

        mInspectionPane->SetWindowListener(this);
    } //BuildInspectionPane()

    virtual void
    TimeSliderEvent(TimeSlider *src, long newTime, int userData)
    {
        int t = (newTime-mTimeLine->GetStartTime());
        mVideoPlayer->GoToFrame(t/TIMES_PER_FRAME[mInspectVideoId]);
    }


    // PoliceManListener
    virtual void
    PoliceManClicked(PoliceMan* src, int btn, int state,
                     int x, int y, void* vData)
    {
        int userData = (int) (long long) vData;
        mAlertWindow->SetMailToSelected(userData,true);
    }

    class SubmitButtonListener : public ButtonListener
    {
        SurveillanceApp* mApp;

    public:

        SubmitButtonListener(SurveillanceApp* theApp)
        {
            mApp = theApp;
        }

        virtual void ButtonSelectionEvent(Button *src, void* userData)
        {
            std::vector<int> trackOfVideoIds;
            std::vector<int> timesInSec;
            mApp->GetTrack(trackOfVideoIds, timesInSec);
            if (trackOfVideoIds.size() <= 0)
            {
                std::cout << "cannot send alert without selected positives, since we need a target location for our officers" << std::endl;
                return;
            }
            mApp->mSurveillanceMap->SetTrack(trackOfVideoIds, timesInSec);
            const std::vector<const std::string* const> addressTrack = mApp->mSurveillanceMap->GetCamAddresses(trackOfVideoIds);
            mAlertWindow->SpotLocations(trackOfVideoIds, addressTrack, timesInSec);

            for (int i = 0; i < NR_OF_POLICEMEN; i++)
                mAlertWindow->SetMailToSelected(i,false);
            int policeStatus[NR_OF_POLICEMEN];
            for (int i = 0; i < NR_OF_POLICEMEN; i++)
                policeStatus[i] = POLICE_POSITIONS[i * 3 + 2];
            mAlertWindow->SetMailToStatus(policeStatus);

            mAlertWindow->SubjectString("");
            mAlertWindow->BodyString("\n\n\n\n\n");
            for (int j=0; j<5; j++)
                mAlertWindow->BodyEditor()->DeleteKey();

            mAlertWindow->FromString("M. Worring\nCamera Surveillance");
            mAlertWindow->Urgency(1);

            IdentificationPane* idPane = (IdentificationPane*) userData;

            mAlertWindow->SetSelectedImages(idPane->Positives());
            //idPane->ClearPositives(); Better let operator decide

            mAlertWindow->BringToFront();
            mAlertWindow->SetVisible(true);
            oglFocusWnd = mAlertWindow->SubjectEditor()->GetOGLWND();
        }

        void SetAlertWindow(AlertWindow* wnd)
        {
            mAlertWindow = wnd;
        }

    protected:

        AlertWindow*     mAlertWindow;

    };

    // responds to event buttons in the CameraEventList and
    // to several other buttons
    virtual void ButtonSelectionEvent(Button *src, void* userData)
    {
        if (src == mExitButton)
        {
            delete this;
            exit(0);
        }
        if (src == mSimilarsButton)
        {
            RoiInfo* roiInfo = (RoiInfo*) mSubjectWindow->GetOglView()->UserData1;
            if (!roiInfo)
                return;

            long secsPassed =
                mTimeLine->GetCurrentTime() - mTimeLine->GetStartTime();
            int maxFrameNr = (int)(secsPassed/TIMES_PER_FRAME[roiInfo->videoId]);
            mIdPane->SearchSimilars(*roiInfo, maxFrameNr);
/*
            int userData[2];
            userData[0] = (int) roiInfo;
            userData[1] = maxFrameNr;

            mIdPane->ButtonSelectionEvent(0, (int) userData);
*/
        }
        else if (src == mShowTrackButton)
        {
            std::vector<int> trackOfVideoIds;
            std::vector<int> timesInSec;
            GetTrack(trackOfVideoIds, timesInSec);
            mSurveillanceMap->SetTrack(trackOfVideoIds, timesInSec);
        }
        else if (src == mHideTrackButton)
        {
            mSurveillanceMap->ClearTrack();
        }
#ifdef ALL_MONITORS
        else if (src == mAllCamerasButton)
        {
            bool    visible = mAllCamerasPane->GetVisible();
            mMonitorPane->SetVisible(visible);
            mAllCamerasPane->SetVisible(!visible);
            mAllCamerasButton->SetText(visible ? "Monitor All" : "Monitor 3");
        }
#endif
        else if (src == mTimeLine->OlderThanButton())
        {
            RadioGroup* rG = mCameraEventListPane->WhichCameraRadioGroup();
            Button* btn = rG->GetButton(15);
            rG->ButtonSelectionEvent(btn, (void*)15);
        }
        else
        {
            // RvB: No need to pass videoPlayer around as we have mVideoPlayer
            VideoJpgPlayer*     videoPlayer = (VideoJpgPlayer*) userData;
            CameraEventButton*  eventButton = (CameraEventButton*) src;

            if (src)
            {
                int  camId       = eventButton->CameraId();
                int  videoId     = camId - 1;
                long startTime   = mTimeLine->GetStartTime();
                long elapsedTime = eventButton->Seconds()-startTime;
                VideoInspect(camId, videoId, elapsedTime, eventButton->FrameNr()); 
            }
            else
            {
                videoPlayer->Stop();
                videoPlayer->SetVisible(false);
                mVideoPlayerCamText->SetText("");
            }
        }
    }

    void VideoInspect(int camId, int videoId, long elapsedTime, int frNr=-1)
    {
        mSurveillanceMap->SetSelectedButton(camId - 1);
        mVideoPlayer->OpenVideo(mVideos[videoId]);
        mInspectVideoId = videoId;
        mVideoPlayerListener->SetVideo(videoId);
        mVideoPlayerCamText->SetText(MonitorString(camId-1));

        if (frNr == -1)
        {
            //mVideoPlayer->GoToFrame(elapsedTime/TIMES_PER_FRAME[videoId]);
            int frmNr = elapsedTime/mVideos[videoId].GetTimePerFrame(); // SK: was made Video responsibility
            mVideoPlayer->GoToFrame(elapsedTime/mVideos[videoId].GetTimePerFrame());
        }
        else
            mVideoPlayer->GoToFrame(frNr);

        mVideoPlayer->Stop();
        mVideoPlayer->SetVisible(true);
    }
 

    virtual void
    ButtonSelectionEvent(SurveillanceMap* src, int btnId, void* userData)
    {
        Button* cameraButton = src->GetButton(btnId);
        int x = cameraButton->X() + cameraButton->W();
        int y = cameraButton->Y()-4;
        mMonitorSelector->SetDimensions(x,y,RETAIN,RETAIN);
        mMonitorSelector->SetVisible();
        mMonitorSelector->SetMonitorSelectorListener(this, (void*)btnId);
    }


    virtual void
    MonitorSelectionEvent(MonitorSelector* src, int id, void* userData)
    {
        int  camId = (int)(long long)userData;
        mCameraTexts[id]->SetText(MonitorString(camId));
        //mVideoCameras[id]->TimePerFrame(TIMES_PER_FRAME[camId]); // SK: now taken from the video obj
        mVideoCameras[id]->OpenVideo(mVideos[camId]);
        mVideoCameras[id]->OglView()->rotZ = -180;
        mVideoCamerasVideoId[id] = camId;
    }

    virtual void
    WindowMouseEvent(Window *src, int msg, int but, int state,
                     int x, int y, void* vData )
    {
        int userData = (int)(long long) vData;
        if (src == mInspectionPane &&
            msg == oglMouseDblClick && (state&oglControl))
        {
            if (state&oglLeftButton)
                mExitButton->SetVisible(!mExitButton->GetVisible());
            if (state&oglRightButton)
            {
                if(state&oglShift)
                    mVideoPlayerView->mShowFrameNr = !mVideoPlayerView->mShowFrameNr;
                else
                    mFramesPerSecond->SetVisible(!mFramesPerSecond->GetVisible());
            }
        }
        if (src == mSurveillanceMap && msg == oglMouseDown)
        {
            mMonitorSelector->SetVisible(false);
            printf("X: %d y: %d\n", x, y);
        }
#ifdef ALL_MONITORS
        else if (msg == oglMouseDown && userData)
        {
            int  frNr = mAllCamerasVideos[userData-1]->FrameNr();
            long startTime   = mTimeLine->GetStartTime();
            long elapsedTime = mTimeLine->GetCurrentTime()-startTime;
            int  videoId     = userData;
            VideoInspect(videoId, videoId-1, elapsedTime, frNr); 
        }
#endif
        else if (msg == oglMouseDown)
        {
            // If user clicked one of the monitors then display in inspect video
            for (int i=0; i<3; i++)
                if (src == mVideoCameras[i])
                {
                    int frNr = mVideoCameras[i]->FrameNr();
                    long startTime   = mTimeLine->GetStartTime();
                    long elapsedTime = mTimeLine->GetCurrentTime()-startTime;
                    int  videoId     = mVideoCamerasVideoId[i];
                    VideoInspect(videoId+1, videoId, elapsedTime, frNr); 
                }
        }
    }

    void GuiEvent(Window* src, void* userData)
    {
        if (src == mIdPane)
        {
            RoiInfo* roiInfo = (RoiInfo*) userData;
            if (roiInfo->videoId > -1)
            {
                mInspectVideoId = roiInfo->videoId;
                mVideoPlayer->OpenVideo(mVideos[roiInfo->videoId]);
                mVideoPlayer->GoToFrame(roiInfo->frameNr);
                mVideoPlayerListener->SetVideo(roiInfo->videoId);
                int camId = roiInfo->videoId + 1;
                //mVideoPlayerCamText->SetText("camera: " + MakeString(camId));
                mVideoPlayerCamText->SetText(MonitorString(camId-1));
            }
            else
                std::cout << "invalid video id in GuiEvent" << std::endl;
        }
    }

// Second screen showing city map with camera buttons
    void BuildSecondScreenGUI()
    {
        OGLIMAGE*        im = TryReadPNG("map.png");
        float            imW = (float) im->w, imH = (float) im->h;

        mSurveillanceMap = new SurveillanceMap(1280, 0, 1272, 990, im);
        oglSys.ReleaseOglImage(im);

        // Google map coordinates.
        int Xs[] = {230, 271, 384, 294, 743, 682, 576, 556, 566, 682, 791, 623,    551, 571, 591};
        int Ys[] = {23,   49, 122, 274, 460, 342, 725, 832, 812, 935, 826, 592,    763, 769, 775};

        char buf[10];
        for (int i=0; i<NR_OF_CAMERAS; i++)
        {
            float   x = Xs[i];
            float   y = Ys[i];
            sprintf(buf,"%d",i+1);
            mSurveillanceMap->CreateButton(x, y, buf);
        }

        mSurveillanceMap->SelectButton(3);
        mSurveillanceMap->ScaleChildren();

        // Prevent others from scaling the children of the map.
        // That is, suppose this class becomes part of a much larger app,
        // and the larger app programmer is a lazy bastard and he
        // just calls ScaleChildren(0,1), 0: no restrictions, 1:recursively
        // on its top level window. We don't mind the map being scaled,
        // but prevent the children of being scaled twice
        // as we do scaling our-selves in the statement above.
        mSurveillanceMap->SetAllowChildScaling(false);
        mSurveillanceMap->Start();
    }

    // Schedules events on seconds relative to start-up;
    // note that the virtual event time has to be set dynamically;
    // also note that cam events use cam nrs (1, 2, ...)
    void ScheduleCamEvents(std::map<int, std::vector<CameraEvent> >& camEventSchedule)
    {
        // 'oude' test-events van Richard:
        camEventSchedule[1].push_back(CameraEvent(10, 1, "by Richard"));
        camEventSchedule[4].push_back(CameraEvent(1, 1, "by Richard"));

        // de extra jeroen-demo-momenten:
        camEventSchedule[55].push_back(CameraEvent(5, 1, "for Jeroen"));
        // RvB: Commented line below jumps to exact frameNr.
        camEventSchedule[55].push_back(CameraEvent(5, 1, 174, "for Jeroen"));
        //camEventSchedule[193].push_back(CameraEvent(7, 1, "for Jeroen"));

        // enkele test-events van Sander
        camEventSchedule[3303 * mVideos[1].GetTimePerFrame()].push_back(CameraEvent(2, 1, 3303, "by Sander"));
        camEventSchedule[3490 * mVideos[1].GetTimePerFrame()].push_back(CameraEvent(2, 1, 3490, "by Sander"));
        camEventSchedule[4426 * mVideos[6].GetTimePerFrame()].push_back(CameraEvent(7, 1, 4426, "by Sander"));

        // het jurrien moment van Marcel
        camEventSchedule[578 * mVideos[1].GetTimePerFrame()].push_back(CameraEvent(2, 1, 578, "Jurrien"));

        // SK: no longer random events
        //for (int i = 0; i < 10; i++)
        //{
        //    int id = 1 + ABSRND(NR_OF_CAMERAS);
        //    int type = 1 + ABSRND(4);
        //    int timeSec = ABSRND(VIRTUAL_TIME_OFFSET);
        //    camEventSchedule[timeSec].push_back(CameraEvent(id, type, "random,pre"));
        //}

        ReadActivityEvents(camEventSchedule);

        ReadCameraMovements(camEventSchedule);
    }

    //void ReadCameraMovements()
    //{
    //    CameraMovementReader reader;
    //    reader.Read2(gCamMovementInfoPath, mVideos);
    //}

    void ReadCameraMovements(std::map<int, std::vector<CameraEvent> >& camEventSchedule)
    {
        CameraMovementReader reader;
        reader.Read(gCamMovementInfoPath, mVideos, camEventSchedule);
    }

    void ReadActivityEvents(std::map<int, std::vector<CameraEvent> >& camEventSchedule)
    {
        ActivityReader reader;
        if (reader.ProperlyConstructed())
            reader.Read(gXmlPathMichael, camEventSchedule);
    }

    void SetupVideoData(std::vector<Visualization::Video>& videos)
    {
        for (int thang = 0; thang < NR_OF_CAMERAS_STREET; thang++)
        {
            int nrFrames = MAX_FRAMES[thang];
            Visualization::Video video(nrFrames, TIMES_PER_FRAME[thang]);
            video.mType = 0;
            video.mId = thang;
            video.mSubId = thang;
            const std::string& videoName = VIDEO_NAMES_STREET[video.mId % NR_OF_CAMERAS_STREET];
            video.mBasePath = gVideoPathThang + videoName + "/" + videoName + std::string("_");
            video.mFileNameSuffix = ".jpg";
            video.mBasePathAnnotated = "";
            video.mFileNameSuffixAnnotated = "";
            videos.push_back(video);
        }

        for (int michael = 0; michael < NR_OF_CAMERAS_STATION; michael++)
        {
#ifdef RICHARD
            Visualization::Video video(20, TIMES_PER_FRAME[NR_OF_CAMERAS_STREET + michael]);
#else
            Visualization::Video video(ActivityReader::TotalSequenceLength(), TIMES_PER_FRAME[NR_OF_CAMERAS_STREET + michael]);
#endif
            video.mType = 1;
            video.mId = NR_OF_CAMERAS_STREET + michael;
            video.mSubId = michael;

#ifdef RICHARD
            video.mBasePath = gVideoPathMichael + "im_000";
            video.mFileNameSuffix = "_r" + MakeString(video.mSubId) + ".jpg";
            video.mBasePathAnnotated = gVideoPathMichael + "imR_000";
            video.mFileNameSuffixAnnotated = "";
#else
            //video.mBasePath = gVideoPathMichael + "pickpocketing/images_400_original/image";
            video.mBasePath = gVideoPathMichael + "original/";
            video.mFileNameSuffix = "_cam" + MakeString(video.mSubId) + ".jpg";
            //video.mBasePathAnnotated = gVideoPathMichael + "pickpocketing/images_400_marked/image";
            video.mBasePathAnnotated = gVideoPathMichael + "marked/";
            video.mFileNameSuffixAnnotated = "";
#endif

            videos.push_back(video);
        }
    }


    void GetTrack(std::vector<int>& trackOfVideoIds, std::vector<int>& trackTimesSec)
    {
        std::vector<int> trackOfFrameNrs;
        mIdPane->SuggestTrack(trackOfVideoIds, trackOfFrameNrs); // track in video id's {0, ..}
        //std::vector<int> timesInSec;
        int startTimeSecs = mTimeLine->GetStartTime();
        for (int i = 0; i < trackOfVideoIds.size(); i++)
        {
            //timesInSec.push_back(i * 300 + 56789); // dummy value
            int frameTimeOffsetSecs = mVideos[trackOfVideoIds[i]].GetTimePast(trackOfFrameNrs[i]);
            trackTimesSec.push_back(startTimeSecs + frameTimeOffsetSecs);
        }
    }


protected:

    Tabs*                       mTabs;

    ApplicationEnding*          mApplicationEnding;

    Window*                     mMonitorPane;
    Window*                     mInspectionPane;

    SurveillanceMap*            mSurveillanceMap;
    AlertTimeLine*              mTimeLine;
    CameraEventListPane*        mCameraEventListPane;

    MonitorSelector*            mMonitorSelector;

    VideoJpgCamera*             mVideoCameras[3];
    int                         mVideoCamerasVideoId[3];

    int                         mInspectVideoId;
    VideoJpgPlayer*             mVideoPlayer;
    VideoJpgPlayerControl*      mVideoPlayerControl;
    VideoPlayerListener*        mVideoPlayerListener;
    VideoPlayerView*            mVideoPlayerView;
    StaticText*                 mVideoPlayerCamText;
    TimeSlider*                 mVideoTimeSlider;

    Button*                     mSimilarsButton;

    Button*                     mShowTrackButton;
    Button*                     mHideTrackButton;
    Button*                     mSubmitButton;
    Button*                     mExitButton;

#ifdef ALL_MONITORS
TitledWindow*     mAllCamerasPane;
Button*           mAllCamerasButton;
VideoJpgCamera*   mAllCamerasVideos[NR_OF_CAMERAS_STREET];
#endif

    StaticText*                 mCameraTexts[3];
    Button*                     mAltBtns[3];

    //int                         mMaxVideoFrame;

    RegionsOfInterestInfo*      mDetectedPersons;
    RegionsOfInterestCorrelation* 
                                mSimilarPersons;

    IdentificationPane*         mIdPane;
    WindowView2D*               mSubjectWindow;

    AlertWindow*                mAlertWindow;

    FramesPerSecond*            mFramesPerSecond;

    std::vector<Visualization::Video> mVideos;

    std::map<int, std::vector<CameraEvent> > mCamEventSchedule;
    std::map<int, std::vector<CameraEvent> >::iterator mCamEventSchedulePosition;

}; //class SurveillanceApp

} // namespace SDash
} // namespace Application
} // namespace Impala



using namespace Impala::Application::SDash;

int main(int argc, char* argv[])
{
    Impala::CmdOptions& options = Impala::CmdOptions::GetInstance();
    options.Initialise(false, false, false);

    if (! options.ParseArgs(argc, argv, "<data root path> <ip-address>", 1))
    {
        fprintf( stderr, "command line parsing failed\n" );
        return 1;
    }

    gDataRoot = options.GetArg(0) + std::string("/");
    gVideoPathThang = gDataRoot + std::string("thang/video/");
    gRoiPath = gDataRoot + std::string("thang/roi/");

#ifdef RICHARD
    gVideoPathMichael = gDataRoot + std::string("michael/GD_sequence/");
    gXmlPathMichael = gVideoPathMichael;
#else
    gVideoPathMichael = gDataRoot + std::string("michael/images/");
    gXmlPathMichael = gDataRoot + std::string("michael/annotation/");
#endif
    gCamMovementInfoPath = gDataRoot + std::string("nicolaas/");

    gIpAddress = argc > 1 ? options.GetArg(1) : "";

    //{
    //    AlertRelay relay(gIpAddress);
    //    if (relay.IsReady())
    //    {
    //        relay.Relay("first message from sdash");
    //        relay.Relay("second message from sdash");
    //    }
    //}

    OglInit(&argc, &argv[0]);

    SurveillanceApp* wnd = new SurveillanceApp(1272, 960);

    if (!wnd->Valid())
    {
        fprintf( stderr, "GUI setup failed\n" );
        return 2;
    }

    OglEventLoop();

    wnd->CleanUp();
    
    return 0;
}

---