D:/~Research/Code/C++/EvolveTraffic/EvolveTrafficView.cpp

Go to the documentation of this file.

// EvolveTrafficView.cpp : implementation of the CEvolveTrafficView class
//

#include "stdafx.h"
#include "EvolveTraffic.h"

#include "EvolveTrafficDoc.h"
#include "EvolveTrafficView.h"
#include "SimConfigDlg.h"
#include "TrafficConfigDlg.h"
#include "PreferencesDlg.h"
#include "RoadFeaturesDlg.h"
#include "RoadFeature.h"
#include "StatDetectorDlg.h"
#include "StatDetector.h"

#include "WindowToBMP.h"

#include <Mmsystem.h>           // Multimedia library for timeGetTime() function

extern CConfigData g_ConfigData;

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

// CEvolveTrafficView

IMPLEMENT_DYNCREATE(CEvolveTrafficView, CScrollView)

BEGIN_MESSAGE_MAP(CEvolveTrafficView, CScrollView)
        //{{AFX_MSG_MAP(CEvolveTrafficView)
        ON_COMMAND(ID_CONFIG_SIM, OnConfigSim)
        ON_COMMAND(ID_RUN_VISIBLE, OnRunVisible)
        ON_WM_SIZE()
        ON_COMMAND(ID_CONFIG_TRAF, OnConfigTraf)
        ON_COMMAND(ID_TOOLS_PREFS, OnToolsPrefs)
        ON_COMMAND(ID_TOOLS_PAUSE, OnToolsPause)
        ON_COMMAND(ID_TOOLS_ZOOMIN, OnToolsZoomin)
        ON_COMMAND(ID_TOOLS_ZOOMOUT, OnToolsZoomout)
        ON_COMMAND(ID_TOOLS_SPEEDUP, OnToolsSpeedup)
        ON_COMMAND(ID_TOOLS_SLOWDOWN, OnToolsSlowdown)
        ON_WM_KEYDOWN()
        ON_COMMAND(ID_RUN_INVISIBLE, OnRunInvisible)
        ON_COMMAND(ID_CONFIG_FEATURES, OnConfigFeatures)
        ON_COMMAND(ID_CONFIG_METRICS, OnConfigMetrics)
        ON_UPDATE_COMMAND_UI(ID_TOOLS_PAUSE, OnUpdateToolsPause)
        ON_UPDATE_COMMAND_UI(ID_TOOLS_SPEEDUP, OnUpdateToolsSpeedup)
        ON_UPDATE_COMMAND_UI(ID_TOOLS_SLOWDOWN, OnUpdateToolsSlowdown)
        ON_COMMAND(ID_TOOLS_STOP, OnToolsStop)
        ON_UPDATE_COMMAND_UI(ID_TOOLS_STOP, OnUpdateToolsStop)
        ON_WM_LBUTTONDOWN()
        ON_COMMAND(ID_FILE_SAVEIMAGE, OnFileSaveImage)
        //}}AFX_MSG_MAP
        // Standard printing commands
        ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
        ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
        ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
END_MESSAGE_MAP()

// CEvolveTrafficView construction/destruction

CEvolveTrafficView::CEvolveTrafficView()
{
        // Configuration Settings
        MIN_VIEW_SCALE          = g_ConfigData.View.MIN_VIEW_SCALE;
        DATATIP_DELAY           = g_ConfigData.View.DATATIP_DELAY;

        CLR_BACKGRND            = g_ConfigData.View.Colours.DrawElements.CLR_BACKGRND;
        CLR_DET_COMPOSITION = g_ConfigData.View.Colours.DrawElements.CLR_DET_COMPOSITION;
        CLR_DET_FLOWDENSITY = g_ConfigData.View.Colours.DrawElements.CLR_DET_FLOWDENSITY;
        CLR_DET_HEADWAY         = g_ConfigData.View.Colours.DrawElements.CLR_DET_HEADWAY;
        CLR_DET_OUTPUT          = g_ConfigData.View.Colours.DrawElements.CLR_DET_OUTPUT;
        CLR_FEAT_GRADIENT       = g_ConfigData.View.Colours.DrawElements.CLR_FEAT_GRADIENT;
        CLR_FEAT_SPEEDLIMIT     = g_ConfigData.View.Colours.DrawElements.CLR_FEAT_SPEEDLIMIT;
        CLR_LEGEND_TEXT         = g_ConfigData.View.Colours.DrawElements.CLR_LEGEND_TEXT;
        CLR_ROAD_LINES          = g_ConfigData.View.Colours.DrawElements.CLR_ROAD_LINES;
        CLR_ROAD_SURFACE        = g_ConfigData.View.Colours.DrawElements.CLR_ROAD_SURFACE;
        CLR_RULER_LINES         = g_ConfigData.View.Colours.DrawElements.CLR_RULER_LINES;
        CLR_RULER_TEXT          = g_ConfigData.View.Colours.DrawElements.CLR_RULER_TEXT;

        VEH_COLOR_CAR                   = g_ConfigData.View.Colours.Vehicles.VEH_COLOR_CAR;
        VEH_COLOR_SMALLTRUCK    = g_ConfigData.View.Colours.Vehicles.VEH_COLOR_SMALLTRUCK;
        VEH_COLOR_LARGETRUCK    = g_ConfigData.View.Colours.Vehicles.VEH_COLOR_LARGETRUCK;
        VEH_COLOR_CRANE                 = g_ConfigData.View.Colours.Vehicles.VEH_COLOR_CRANE;
        VEH_COLOR_LOWLOADER             = g_ConfigData.View.Colours.Vehicles.VEH_COLOR_LOWLOADER;

        // Initial view scale
        m_Scale = 1.0;
        m_ExaggerateWidths       = 10.0;
        
        m_Border_Top                    = 20;
        m_Border_Btm                    = 40;
        m_Border_Lhs                    = 20;
        m_Border_Rhs                    = 100;
        m_TickStep                              = 500;
        m_VehicleLengthScale    = 2.0;  // so they look ok - results in overlaps??
        m_bShowVelocity                 = true;
        m_bShowLegend                   = true;
        m_TickLength                    = 1.0 * m_ExaggerateWidths;
        m_LaneWidth                             = 4.0 * m_ExaggerateWidths;
        m_VehicleWidth                  = 3.0 * m_ExaggerateWidths;             // less than lane width! 
        
        m_bInSimulation = false;        // has a simulation begun
        m_bPause = false;                       // is the simulation to progress one step
        m_TimeWarp = 1;                         // multiplier of real time that the simulation runs
        // the timer speed is constant since the refresh rate is constant
        m_TimerSpeed = Round(1000/DRAW_FRAMES_PER_SEC); // in int ms
        m_CurentRealTime = 0;           // actual time since simulation started
        m_CurentSimTime = 0;            // sim time since sim started
        m_PauseTime = 0;                        // the time the sim was paused at
        m_MaxTimeWarp = 1000;           // a high number - will be reduced as sim progresses

        m_LastPercentComplete = 0;
        m_PercentComplete = 0;

        m_YCoordTop = 0;        // legacy - need to remove
}

CEvolveTrafficView::~CEvolveTrafficView()
{

}

BOOL CEvolveTrafficView::PreCreateWindow(CREATESTRUCT& cs)
{
        // TODO: Modify the Window class or styles here by modifying
        //  the CREATESTRUCT cs

        return CScrollView::PreCreateWindow(cs);
}

// CEvolveTrafficView drawing

void CEvolveTrafficView::OnInitialUpdate()
{
        m_DrawArea.cx = 5000;
        m_DrawArea.cy = 100;
        
        CScrollView::OnInitialUpdate();
        
        m_pDoc = GetDocument();
        ASSERT_VALID(m_pDoc);

        initRoad();
        if(m_DataTip.m_hWnd == NULL)
        {
                m_DataTip.Create(this);
                m_DataTip.SetDisplayTime( Round(DATATIP_DELAY*1000) );
        }

}

void CEvolveTrafficView::OnPrepareDC(CDC *pDC, CPrintInfo *pInfo)
{
        CScrollView::OnPrepareDC(pDC, pInfo);

        pDC->SetMapMode(MM_ANISOTROPIC);        // for scaling
        pDC->SetWindowExt(m_DrawArea);          // in logical units

        int xExtent = m_Scale * m_DrawArea.cx;
        int yExtent = m_Scale * m_DrawArea.cy;
        pDC->SetViewportExt(xExtent, yExtent);

        // keep the road divider in the centre of screen
        // by moving the viewport origin
        GetClientRect(&m_ClientRect);   // the height of the window
        CPoint viewOrg;
        viewOrg.y = m_ClientRect.Height()/2;    // - yExtent/2;
        viewOrg.x = m_Border_Lhs*m_Scale;
        
        viewOrg -= GetDeviceScrollPosition();   // so scrolling accounted for
        pDC->SetViewportOrg(viewOrg);
}

void CEvolveTrafficView::SetZoomScale(double newScale)
{
        if(newScale > MIN_VIEW_SCALE)
        {
                double oldZoomFactor = m_Scale;
                
                CPoint centerScrollPosition = GetScrollPosition();
                CRect ClientRect(0,0,0,0);
                centerScrollPosition.x += m_ClientRect.right/2;
                centerScrollPosition.y += m_ClientRect.bottom/2;

                m_Scale = newScale;
                
                CSize displaySize;
                displaySize.cx = Round(m_DrawArea.cx * m_Scale);
                displaySize.cy = Round(m_DrawArea.cy * m_Scale);
                SetScrollSizes(MM_TEXT,displaySize);
                
                int newXScrollPosition = Round((centerScrollPosition.x / oldZoomFactor) * m_Scale);
                int newYScrollPosition = Round((centerScrollPosition.y / oldZoomFactor) * m_Scale);

                newXScrollPosition -= m_ClientRect.right/2;
                newYScrollPosition -= m_ClientRect.bottom/2;
                ScrollToPosition(CPoint(newXScrollPosition,newYScrollPosition));
        }
        else
        {
                CString str; str.Format("You cannot zoom out any further - minimum view scale is 0.1.", MIN_VIEW_SCALE);
                MessageBox(str, "EvolveTraffic", MB_OK|MB_ICONWARNING);
        }

        Invalidate(FALSE);
}

void CEvolveTrafficView::initRoad()
{
        m_DriveOnRight  = m_pDoc->getDriveOnRight();
        m_RoadLength    = m_pDoc->getRoadLength();
        m_NoLanes               = m_pDoc->getNoLanes();
        m_NoLanesDirPos = m_pDoc->getNoLanesDirPos();
        m_NoLanesDirNeg = m_pDoc->getNoLanesDirNeg();
        m_NoDirections  = m_pDoc->getNoDirections();
        m_RoadWidth             = m_NoLanes * m_LaneWidth;
        m_NoTicks               = (int)(m_RoadLength/m_TickStep)+1;

        m_nLanesOnTop   = m_DriveOnRight ? m_NoLanesDirNeg : m_NoLanesDirPos;
        m_nLanesOnBtm   = m_DriveOnRight ? m_NoLanesDirPos : m_NoLanesDirNeg;
        m_TopEdge               = -m_nLanesOnTop*m_LaneWidth;
        m_BtmEdge               = m_nLanesOnBtm*m_LaneWidth;

        m_SimTimeStep = Round(1000 * m_pDoc->getSimTimeStep()); // constant sim time step

        m_DrawArea.cy =  m_Border_Top + m_Border_Btm + m_RoadWidth;
        m_DrawArea.cx =  m_Border_Lhs + m_Border_Rhs + m_RoadLength;

        CSize scrolls;
        scrolls.cx = m_DrawArea.cx*m_Scale;     // when scale is not 1.0
        scrolls.cy = m_DrawArea.cy*m_Scale;
        CScrollView::SetScrollSizes(MM_TEXT, scrolls);
}

void CEvolveTrafficView::doLoop(int curTime)
{
        int StepTime = Round( (double)m_SimTimeStep/m_TimeWarp );
        static int TimeNextSimStep = m_StartRealTime + StepTime;
        static int TimeNextDraw = m_StartRealTime + m_TimerSpeed;
        
        if(m_bInSimulation && !m_bPause)        // simulating & not paused
        {
                if(curTime > TimeNextSimStep)   // ready for next simstep
                {
                        // note m_bInSimulation will become false if it's the end of the simulation
                        m_VehiclePositions = m_pDoc->m_Sim.doOneTimeStep(&m_bInSimulation);
                        UpdateProgressBar();

                        if(!m_bInSimulation) // we were in a simulation and now we're not - ie it's just finished
                                doSimFinished(true);    // true means completed

                        while(TimeNextSimStep < curTime)
                                TimeNextSimStep += StepTime;
                }
        }
        
        if(curTime > TimeNextDraw)                      // ready for next frame?
        {
                InvalidateRect(NULL,FALSE);             // draw it
                while(TimeNextDraw < curTime)
                        TimeNextDraw += m_TimerSpeed;
        }
}

void CEvolveTrafficView::UpdateProgressBar()
{
        m_PercentComplete = m_pDoc->m_Sim.getPercentComplete();

        if(m_PercentComplete > m_LastPercentComplete)
        {
                CString str;
                str.Format("%d%% complete", m_PercentComplete);
                m_pProgBar->SetText(str);
                m_pProgBar->StepIt();
                m_LastPercentComplete = m_PercentComplete;
                Invalidate(FALSE);      // called so that during invisible the bar is still seen
        }
}

void CEvolveTrafficView::OnDraw(CDC* dc)
{
        CMemDC pDC(dc);

        DrawRoad(pDC);
        DrawRuler(pDC);
        
        if(m_bShowLegend)
                DrawLegend(pDC);
        
        if(m_bInSimulation)             // we're in a simulation
        {
                // draw the vehicles where they are
                for (int i = 0; i < m_VehiclePositions.size(); i++)                     // Total number of lanes
                {
                        for (int j = 0; j < m_VehiclePositions[i].size(); j++)  // No vehicles in each lane
                                        DrawVehicle(pDC, m_VehiclePositions[i][j]);
                }
        }

        DrawTimer(pDC); // always draw & last so it's on top

}

// CEvolveTrafficView printing

BOOL CEvolveTrafficView::OnPreparePrinting(CPrintInfo* pInfo)
{
        // default preparation
        return DoPreparePrinting(pInfo);
}

void CEvolveTrafficView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
        // TODO: add extra initialization before printing
}

void CEvolveTrafficView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
        // TODO: add cleanup after printing
}

// CEvolveTrafficView diagnostics

#ifdef _DEBUG
void CEvolveTrafficView::AssertValid() const
{
        CScrollView::AssertValid();
}

void CEvolveTrafficView::Dump(CDumpContext& dc) const
{
        CScrollView::Dump(dc);
}

CEvolveTrafficDoc* CEvolveTrafficView::GetDocument() // non-debug version is inline
{
        ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CEvolveTrafficDoc)));
        return (CEvolveTrafficDoc*)m_pDocument;
}
#endif //_DEBUG

// CEvolveTrafficView message handlers

void CEvolveTrafficView::OnRunVisible() 
{
        if( !m_bInSimulation )
                doSimStart();
        else
        {
                if(m_bPause)            // give this button start stop behaviour as well
                        OnToolsPause();
                else
                        MessageBox("Simulation already running", "EvolveTraffic", MB_OK|MB_ICONWARNING);
        }
}

void CEvolveTrafficView::OnRunInvisible() 
{
        if( !m_bInSimulation )
        {
                int result = MessageBox("Running EvolveTraffic in this mode means:\n"
                                                                "- only the progress bar is updated;\n"
                                                                "- the program will appear to be unresponsive until the simulation is complete.\n"
                                                                "Are you sure that you want to proceed in this mode?",
                                                                "EvolveTraffic", MB_YESNO|MB_ICONWARNING);

                if(result == IDYES)     // we're cleared to go
                {
                        doSimStart();
                        bool bInSim = true;             // local inSim - we want class-wide InSim to persist longer than this loop
                        while(bInSim)
                        {
                                m_pDoc->m_Sim.doOneTimeStep(&bInSim);   // bInSim becomes false when sim is over
                                UpdateProgressBar();
                        }
                        m_CurentSimTime = m_pDoc->m_Sim.getCurrentSimTime();
                        m_CurentRealTime = timeGetTime() - m_StartRealTime;     // no need for PauseTime since no pause
                        doSimFinished(true);    // no need to check if it's finished - true means completed
                }
        }
        else
                MessageBox("Simulation already running", "EvolveTraffic", MB_OK|MB_ICONWARNING);
        
}

void CEvolveTrafficView::doSimStart()
{
        bool statusOK = m_pDoc->initSim();
        if(statusOK)
        {
                ((CEvolveTrafficApp*)AfxGetApp())->setInSimulation(true);
                m_StartRealTime = timeGetTime();
                m_bInSimulation = true;                         // this means the doLoop() becomes active
                m_CurentSimTime = 0.0;
                m_pProgBar = new CProgressBar;
                m_pProgBar->Create("Percent Complete 0%");
                Invalidate();   // refresh screen before starting
        }
}

void CEvolveTrafficView::doSimFinished(bool bCompleted)
{
        Invalidate();                                                                                           // draw last screen
        m_bInSimulation = false;                                                                        // tell overall class we're done
        ((CEvolveTrafficApp*)AfxGetApp())->setInSimulation(false);      // tell the sim loop to stop
        m_pProgBar->Clear();                                                                            // clear and
        delete m_pProgBar;                                                                                      // delete the current progress bar
        m_pDoc->m_Sim.clear();                                                                          // clear the simulation
        m_LastPercentComplete = 0;                                                                      // reset the percent complete
        m_VehiclePositions.clear();                                                                     // clear vehicles

        if(bCompleted)
                MessageBox("The simulation has finished.","EvolveTraffic",MB_OK|MB_ICONINFORMATION);
}

// this function is called when the current timewarp results in
// no sleep time necessary to slow the simulation, i.e. max possible timewarp
void CEvolveTrafficView::setMaxTimeWarp()
{
        m_MaxTimeWarp = m_TimeWarp;
}

void CEvolveTrafficView::OnSize(UINT nType, int cx, int cy) 
{
        CScrollView::OnSize(nType, cx, cy);
}

void CEvolveTrafficView::OnToolsPause() 
{
        if(m_bPause)    // currently paused - about to not be
        {
                m_PauseTime = timeGetTime() - m_PauseTime;      // calc total pause time
                m_StartRealTime += m_PauseTime;                                 // so time just carries on
        }
        else                    // not paused - but about to be
                m_PauseTime = timeGetTime();                            // save initial pause time

        m_bPause = !m_bPause;           // so pause/start behaviour

}

void CEvolveTrafficView::OnToolsStop() 
{
        doSimFinished(false);   // false means not compelted, but stopped midway through
}

void CEvolveTrafficView::OnUpdateToolsStop(CCmdUI* pCmdUI) 
{
        if(m_bInSimulation)
                pCmdUI->Enable(true);
        else
                pCmdUI->Enable(false);  
}

void CEvolveTrafficView::OnUpdateToolsPause(CCmdUI* pCmdUI) 
{
        if(m_bInSimulation)
        {
                pCmdUI->Enable(true);
                if(m_bPause)
                        pCmdUI->SetText("&Resume\tF9");
                else
                        pCmdUI->SetText("&Pause\tF9");
        }
        else
                pCmdUI->Enable(false);
        
}

void CEvolveTrafficView::OnUpdateToolsSpeedup(CCmdUI* pCmdUI) 
{
        if(m_bInSimulation)
                pCmdUI->Enable(true);
        else
                pCmdUI->Enable(false);  
}

void CEvolveTrafficView::OnUpdateToolsSlowdown(CCmdUI* pCmdUI) 
{
        if(m_bInSimulation)
                pCmdUI->Enable(true);
        else
                pCmdUI->Enable(false);  
}

void CEvolveTrafficView::SettingUpdateRedraw()
{
        initRoad();             // re-do the road properties
        Invalidate();   // draw it
}

void CEvolveTrafficView::ValidateTimeWarp()
{
        if(m_TimeWarp > m_MaxTimeWarp)
        {
                m_TimeWarp = m_MaxTimeWarp;
                CString str;    str.Format("Maximum time warp reached (%.2f) for this simulation.",m_TimeWarp);
                MessageBox(str,"EvolveTraffic",MB_OK|MB_ICONINFORMATION);
        }
        if(m_TimeWarp < 0.5)    // set half speed as minimum
        {
                m_TimeWarp = 1.0;
                MessageBox("Half of real-time speed is the minimum time warp.","EvolveTraffic",MB_OK|MB_ICONINFORMATION);
        }
}

void CEvolveTrafficView::OnToolsZoomin() 
{
        SetZoomScale(m_Scale + 0.2);    // MAGIC NUMBER - should it be an option?
}

void CEvolveTrafficView::OnToolsZoomout() 
{
        SetZoomScale(m_Scale - 0.2);    // MAGIC NUMBER - should it be an option?
}

void CEvolveTrafficView::OnToolsSpeedup() 
{
        m_TimeWarp += 1.0;                              // MAGIC NUMBER - should it be an option?

        ValidateTimeWarp();
}

void CEvolveTrafficView::OnToolsSlowdown() 
{
        m_TimeWarp -= 1.0;                              // MAGIC NUMBER - should it be an option?

        ValidateTimeWarp();
}

void CEvolveTrafficView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
        CScrollView::OnKeyDown(nChar, nRepCnt, nFlags);

        POINT curPoint = GetScrollPosition();
        int deltaX = Round(m_RoadLength/10);    // MAGIC NUMBER - scroll 1/10 of road

        switch(nChar)
        {
                case VK_RIGHT:
                        curPoint.x += deltaX;   
                        break;
                case VK_LEFT:
                        curPoint.x -= deltaX;
                        break;
                case VK_HOME:
                        curPoint.x = 0;
                        break;
                case VK_END:
                        CSize temp = GetTotalSize();
                        curPoint.x = temp.cx;
                        break;
        }
        ScrollToPosition(curPoint);
        Invalidate(FALSE);
}


void CEvolveTrafficView::OnFileSaveImage() 
{
        CFileDialog FileDlg(
                FALSE,                  // TRUE if File Open, FALSE if File Save As
                _T("*.bmp"),    // the default file extension
                NULL,                   // the initial filename that appears
                OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,//flags for customizing the appearance
                "Bitmap files (*.bmp) |*.bmp||",        // file filters
                this); // pointer to FileCialog's parent object

        if(FileDlg.DoModal() == IDOK)
        {
                CString file = FileDlg.GetPathName();
                UpdateWindow();         // to get rid of dialog
                CWindowToBMP convert;
                if( convert.Write(file, this) )
                        MessageBox("Image saved.","EvolveTraffic", MB_OK|MB_ICONINFORMATION);
                else
                        MessageBox("Image saving failed.","EvolveTraffic", MB_OK|MB_ICONWARNING);
        }       
}

void CEvolveTrafficView::OnConfigSim()
{
        CSimConfigDlg SimDlg;

        SimDlg.m_FileIn                 = m_pDoc->getFileIn();
        SimDlg.m_FileOut                = m_pDoc->getFileOut();
        SimDlg.m_MetricsDir             = m_pDoc->getMetricsDir();
        SimDlg.m_FileType               = m_pDoc->getFileType();
        SimDlg.m_RoadLength             = m_pDoc->getRoadLength();
        SimDlg.m_DriveOnRight   = m_pDoc->getDriveOnRight();
        SimDlg.m_NoLanesDirPos  = m_pDoc->getNoLanesDirPos();
        SimDlg.m_NoLanesDirNeg  = m_pDoc->getNoLanesDirNeg();
        SimDlg.m_SimTimeStep    = (int)(m_pDoc->getSimTimeStep() * 1000);       // seconds to milliseconds
        
        SimDlg.m_AllowLaneChanging                      = m_pDoc->getAllowLaneChanging();
        SimDlg.m_TrafFileNoLanesDirPos          = m_pDoc->getTrafFileNoLanesDirPos();
        SimDlg.m_TrafFileNoLanesDirNeg          = m_pDoc->getTrafFileNoLanesDirNeg();
        SimDlg.m_LocOutputDetectorDirPos        = m_pDoc->getLocOutputDetectorDirPos();
        SimDlg.m_LocOutputDetectorDirNeg        = m_pDoc->getLocOutputDetectorDirNeg();

        if(SimDlg.DoModal() == IDOK)
        {
                m_pDoc->setFileIn(                      SimDlg.m_FileIn         );
                m_pDoc->setFileOut(                     SimDlg.m_FileOut        );
                m_pDoc->setMetricsDir(          SimDlg.m_MetricsDir     );
                m_pDoc->setFileType(            SimDlg.m_FileType       );
                m_pDoc->setRoadLength(          SimDlg.m_RoadLength     );
                m_pDoc->setDriveOnRight(        SimDlg.m_DriveOnRight );
                m_pDoc->setNoLanesDirPos(       SimDlg.m_NoLanesDirPos);
                m_pDoc->setNoLanesDirNeg(       SimDlg.m_NoLanesDirNeg);
                m_pDoc->setSimTimeStep(         (double)SimDlg.m_SimTimeStep / 1000 );  // milliseconds to seconds
                
                m_pDoc->setAllowLaneChanging(           SimDlg.m_AllowLaneChanging );
                m_pDoc->setTrafFileNoLanesDirPos(       SimDlg.m_TrafFileNoLanesDirPos );
                m_pDoc->setTrafFileNoLanesDirNeg(       SimDlg.m_TrafFileNoLanesDirNeg );
                m_pDoc->setLocOutputDetectorDirPos( SimDlg.m_LocOutputDetectorDirPos );
                m_pDoc->setLocOutputDetectorDirNeg( SimDlg.m_LocOutputDetectorDirNeg );

                m_pDoc->UpdateDerivedMembers(true);     // call setMod flag
                
                SettingUpdateRedraw();
        };
}

void CEvolveTrafficView::OnConfigTraf() 
{
        CTrafficConfigDlg TrafDlg;

        TrafDlg.m_IDMParams_Car                 = m_pDoc->getIDMParams_Car();
        TrafDlg.m_IDMParams_SmallTruck  = m_pDoc->getIDMParams_SmallTruck();
        TrafDlg.m_IDMParams_LargeTruck  = m_pDoc->getIDMParams_LargeTruck();
        TrafDlg.m_IDMParams_Crane               = m_pDoc->getIDMParams_Crane();
        TrafDlg.m_IDMParams_Lowloader   = m_pDoc->getIDMParams_Lowloader();

        if(TrafDlg.DoModal() == IDOK)
        {
                m_pDoc->setIDMParams_Car                (TrafDlg.m_IDMParams_Car);
                m_pDoc->setIDMParams_SmallTruck (TrafDlg.m_IDMParams_SmallTruck);
                m_pDoc->setIDMParams_LargeTruck (TrafDlg.m_IDMParams_LargeTruck);
                m_pDoc->setIDMParams_Crane              (TrafDlg.m_IDMParams_Crane);
                m_pDoc->setIDMParams_Lowloader  (TrafDlg.m_IDMParams_Lowloader);

                Invalidate();
        }       
}

void CEvolveTrafficView::OnToolsPrefs() 
{
        CPreferencesDlg PrefsDlg;

        PrefsDlg.m_Scale                                = m_Scale;
        PrefsDlg.m_ExaggerateWidths             = m_ExaggerateWidths;
        PrefsDlg.m_TimeWarp                             = m_TimeWarp;
        PrefsDlg.m_TickStep                             = m_TickStep;
        
        PrefsDlg.m_LaneWidth                    = m_LaneWidth   / m_ExaggerateWidths;
        PrefsDlg.m_VehicleWidth                 = m_VehicleWidth/ m_ExaggerateWidths;
        PrefsDlg.m_TickLength                   = m_TickLength  / m_ExaggerateWidths;
        
        PrefsDlg.m_VehicleLengthScale   = m_VehicleLengthScale;
        PrefsDlg.m_ShowVelocity                 = m_bShowVelocity ? 1 : 0;
        PrefsDlg.m_ShowLegend                   = m_bShowLegend ? 1 : 0;
        PrefsDlg.m_Border_Top                   = m_Border_Top;
        PrefsDlg.m_Border_Btm                   = m_Border_Btm;
        PrefsDlg.m_Border_Lhs                   = m_Border_Lhs;
        PrefsDlg.m_Border_Rhs                   = m_Border_Rhs;

        if(PrefsDlg.DoModal() == IDOK)
        {
                m_Scale                                 =       PrefsDlg.m_Scale;
                m_ExaggerateWidths              =       PrefsDlg.m_ExaggerateWidths;
                m_TimeWarp                              =       PrefsDlg.m_TimeWarp;
                m_TickStep                              =       PrefsDlg.m_TickStep;
                
                m_LaneWidth                             =       PrefsDlg.m_LaneWidth    * m_ExaggerateWidths;
                m_VehicleWidth                  =       PrefsDlg.m_VehicleWidth * m_ExaggerateWidths;
                m_TickLength                    =       PrefsDlg.m_TickLength   * m_ExaggerateWidths;

                m_VehicleLengthScale    =       PrefsDlg.m_VehicleLengthScale;
                m_bShowVelocity                 =       PrefsDlg.m_ShowVelocity == 0 ? false : true;
                m_bShowLegend                   =       PrefsDlg.m_ShowLegend == 0 ? false : true;
                m_Border_Top                    =       PrefsDlg.m_Border_Top;
                m_Border_Btm                    =       PrefsDlg.m_Border_Btm;
                m_Border_Lhs                    =       PrefsDlg.m_Border_Lhs;
                m_Border_Rhs                    =       PrefsDlg.m_Border_Rhs;

                SettingUpdateRedraw();
        }
}

void CEvolveTrafficView::OnConfigFeatures() 
{
        CRoadFeaturesDlg FeaturesDlg;

        FeaturesDlg.m_RoadLength = m_RoadLength;        // for validation purposes only
        FeaturesDlg.m_vRoadFeatures.Copy( *(m_pDoc->getRoadFeatures()) );

        if( FeaturesDlg.DoModal() == IDOK )
                m_pDoc->setRoadFeatures( &(FeaturesDlg.m_vRoadFeatures) );

        Invalidate();
}

void CEvolveTrafficView::OnConfigMetrics() 
{
        CStatDetectorDlg StatDetDlg;
        
        StatDetDlg.m_RoadLength = m_RoadLength; // for validation purposes only
        StatDetDlg.m_vStatDetectors.Copy( *(m_pDoc->getStatDetectors()) );

        if( StatDetDlg.DoModal() == IDOK )
                m_pDoc->setStatDetectors( &(StatDetDlg.m_vStatDetectors) );

        Invalidate();   
}


void CEvolveTrafficView::OnLButtonDown(UINT nFlags, CPoint point) 
{
        if(m_bPause)    // only if paused
        {
                // Get road coords
                CClientDC aDC(this);
                OnPrepareDC(&aDC);
                CPoint ptRoad = point;
                aDC.DPtoLP(&ptRoad);
                ptRoad.x -= m_Border_Lhs;

                if(ptRoad.y < m_BtmEdge && ptRoad.y > m_TopEdge) // only if within road
                {
                        // Get lane
                        int iLane = 1;
                        int TopOfLane = m_BtmEdge;

                        while(ptRoad.y < TopOfLane)
                        {
                                TopOfLane = m_BtmEdge - iLane*m_LaneWidth;
                                iLane++;
                        }
                        // so it was in the previous lane, but zero based array, i.e.
                        iLane -= 2;
                        if(!m_DriveOnRight)
                                iLane = m_NoLanes - iLane -1;

                        // Find vehicle at pos x in lane iLane
                        Vehicle* pVeh = FindVehicle(iLane, ptRoad.x);
                        
                        if(pVeh != NULL)        // assemble datastring and display
                        {
                                CRect rect(point.x,point.y,point.x+100, point.y+100);   // notice point in screen coords
                                m_DataTip.Show(rect,pVeh->getDataString());
                        }
                }
        }
        
        CScrollView::OnLButtonDown(nFlags, point);
}

Vehicle* CEvolveTrafficView::FindVehicle(int iLane, int location)
{
        Vehicle* pVeh = NULL;
        std::vector<Vehicle*> vLaneVehs = m_VehiclePositions.at(iLane);
        
        for(int i = 0; i < vLaneVehs.size(); i++)
        {
                pVeh = vLaneVehs.at(i);
                int front = pVeh->getRoadPos();
                int length = pVeh->getLength() * m_VehicleLengthScale;

                bool bOnVehicle = false;
                if(pVeh->getDirection())
                {
                        if( location < front && location > front - length )
                                bOnVehicle = true;
                }
                else
                {
                        if( location > front && location < front + length )
                                bOnVehicle = true;
                }

                if( bOnVehicle )
                        return pVeh;
        }

        return NULL;
}


void CEvolveTrafficView::DrawRoad(CMemDC *pDC)
{
        // Prepare brushes
        CPen BlackPen(PS_SOLID, 0, CLR_ROAD_LINES);
        CPen BlackDashPen(PS_DASH, 0, CLR_ROAD_LINES);

        // fill the road surface
        pDC->FillSolidRect(m_Border_Lhs,m_TopEdge,m_RoadLength,m_RoadWidth, CLR_ROAD_SURFACE);
        // draw road segements
        DrawRoadSegments(pDC);
        
        pDC->SelectObject(&BlackPen);
        // Top edge of the road
        pDC->MoveTo(m_Border_Lhs,m_TopEdge);    
        pDC->LineTo(m_Border_Lhs+m_RoadLength,m_TopEdge);
        // bottom edge of the road
        pDC->MoveTo(m_Border_Lhs,m_BtmEdge);    
        pDC->LineTo(m_Border_Lhs+m_RoadLength,m_BtmEdge);
        // for each lane
        pDC->SelectObject(&BlackDashPen);
        int LaneEdge =  m_BtmEdge;
        for (int i = 0; i < m_NoLanes-1; i++)
        {       // from bottom working the way up
                LaneEdge -= m_LaneWidth;
                pDC->MoveTo(m_Border_Lhs,LaneEdge);     
                pDC->LineTo(m_Border_Lhs+m_RoadLength,LaneEdge);
        }
        // Divide carraigeway
        pDC->SelectObject(&BlackPen);
        if(m_NoDirections == 2)
        {
                pDC->MoveTo(m_Border_Lhs,0);    
                pDC->LineTo(m_Border_Lhs+m_RoadLength,0);
        }

        DrawDetectors(pDC);
}

void CEvolveTrafficView::DrawVehicle(CMemDC *pDC, Vehicle* pVeh)
{
        bool DirPointsRight = pVeh->getDirection();     
        int lane = pVeh->getLane();
        int x = pVeh->getRoadPos() + m_Border_Lhs;      // front of vehicle road position to screen position
        int y = 0;                                                                      // just to initialize it

        y = m_DriveOnRight ? m_BtmEdge - (lane-0.5)*m_LaneWidth : m_TopEdge + (lane-0.5)*m_LaneWidth;
        // and subtract half the vehicle width to get the y pos of the top edge
        y = y - m_VehicleWidth/2;

        // So DirNeg vehicles' position corresponds with the front of the vehicle
        int DirectionFactor = DirPointsRight == true ? -1 : +1;
        int cx = DirectionFactor * m_VehicleLengthScale * pVeh->getLength();
        CRect VehRect(x,y,x+cx,y+m_VehicleWidth);
        
        DrawVehicleAt(pDC, pVeh->getID(), VehRect);

        // draw the velocity on the vehicle
        double velocity = pVeh->getVelocity()*M_PER_S_TO_KM_PER_H;

        if(m_bShowVelocity)
        {
                CString SpeedStr; SpeedStr.Format("%3.1f", velocity);
                CSize strSize = pDC->GetTextExtent(SpeedStr);
                x = x + cx/2 - strSize.cx/2;
                y = y + m_VehicleWidth/2 - strSize.cy/2;
                pDC->TextOut(x,y,SpeedStr);
        }
}

void CEvolveTrafficView::DrawVehicleAt(CMemDC *pDC, WORD VEH_ID, CRect VehRect)
{
        switch(VEH_ID)
        {
                case VEH_ID_CAR:
                        pDC->FillSolidRect(VehRect, VEH_COLOR_CAR);
                        break;
                case VEH_ID_SMALLTRUCK:
                        pDC->FillSolidRect(VehRect, VEH_COLOR_SMALLTRUCK);
                        break;
                case VEH_ID_LARGETRUCK:
                        pDC->FillSolidRect(VehRect, VEH_COLOR_LARGETRUCK);
                        break;
                case VEH_ID_CRANE:
                        pDC->FillSolidRect(VehRect, VEH_COLOR_CRANE);
                        break;
                case VEH_ID_LOWLOADER:
                        pDC->FillSolidRect(VehRect, VEH_COLOR_LOWLOADER);
                        break;
                default:
                        pDC->FillSolidRect(VehRect, VEH_COLOR_CAR);     // car
        }
}

void CEvolveTrafficView::DrawTimer(CMemDC *pDC)
{
        pDC->SetTextColor(CLR_LEGEND_TEXT);
        pDC->SetBkColor(CLR_BACKGRND);
        
        // Draw the simulation time
        int ypos = Round(-(m_ClientRect.Height()/2)/m_Scale)+m_Border_Top;      // this keeps the timer position scale invariant
        int xpos = m_Border_Lhs;
        
        if(m_bInSimulation)
                m_CurentSimTime = m_pDoc->m_Sim.getCurrentSimTime();

        double temp = m_CurentSimTime;                                                  int day = (int)(temp/(HOURS_PER_DAY * SECS_PER_HOUR));          
        temp = temp - day * HOURS_PER_DAY * SECS_PER_HOUR;              int hr  = (int)(temp/(SECS_PER_HOUR));
        temp = temp - hr * SECS_PER_HOUR;                                               int min = (int)(temp/(MINS_PER_HOUR));
        temp = temp - min * SECS_PER_MIN;                                               double sec      = temp;

        CString SimStr; SimStr.Format("Sim. Time - Day: %d - %d:%02d:%05.2f",day,hr,min,sec);
        CSize strSimSize = pDC->GetTextExtent(SimStr);  // so text is always inside the window
        pDC->TextOut(xpos,ypos,SimStr); // change + to - if drawn on bottom

        // draw the real elapsed time
        if(m_bInSimulation && !m_bPause)        // only update if we're simulating and not paused
                m_CurentRealTime = timeGetTime() - m_StartRealTime;

        temp = (double)m_CurentRealTime/1000;                                   day     = (int)(temp/(HOURS_PER_DAY * SECS_PER_HOUR));
        temp = temp - day * HOURS_PER_DAY * SECS_PER_HOUR;              hr      = (int)(temp/(SECS_PER_HOUR));
        temp = temp - hr * SECS_PER_HOUR;                                               min     = (int)(temp/(MINS_PER_HOUR));
        temp = temp - min * SECS_PER_MIN;                                               sec     = temp;

        CString RealStr; RealStr.Format("Real Time - Day: %d - %d:%02d:%05.2f",day,hr,min,sec);
        CSize strRealSize = pDC->GetTextExtent(RealStr);        // so text is always inside the window
        pDC->TextOut(xpos,ypos + strRealSize.cy*1.2 ,RealStr);  // 20% sapce between strings | change + to - if drawn on bottom 

}

void CEvolveTrafficView::DrawLegend(CMemDC *pDC)
{
        pDC->SetTextColor(CLR_LEGEND_TEXT);
        pDC->SetBkColor(CLR_BACKGRND);
        
        CString strTime = "Real Time - Day: 00 - 00:00:00.00";
        CSize timeSize = pDC->GetTextExtent(strTime);

        // initial positions
        int ypos = Round(-(m_ClientRect.Height()/2)/m_Scale) + m_Border_Top;    // this keeps the timer position scale invariant
        int xpos = m_Border_Lhs + timeSize.cx + m_Border_Lhs;                                   // to avoid a clash with the timer
        int ygap = 20/m_Scale;
        int LineLength = m_Border_Lhs/m_Scale;  // why not!
        int LineToText = 20/m_Scale;
        
        DrawLegendVehicle(pDC, VEH_ID_CAR,                      "Car",                  LineToText, xpos, ypos);                        ypos += ygap;
        DrawLegendVehicle(pDC, VEH_ID_SMALLTRUCK,       "Small Truck",  LineToText, xpos, ypos);                        ypos += ygap;
        DrawLegendVehicle(pDC, VEH_ID_LARGETRUCK,       "Large Truck",  LineToText, xpos, ypos);                        ypos += ygap;
        DrawLegendVehicle(pDC, VEH_ID_CRANE,            "Crane",                LineToText, xpos, ypos);                        ypos += ygap;
        DrawLegendVehicle(pDC, VEH_ID_LOWLOADER,        "Low-loader",   LineToText, xpos, ypos);                        ypos += ygap;

        ypos -= 5*ygap; //reset ypos
        CSize strSize = pDC->GetTextExtent("Large Truck");
        xpos += LineLength+LineToText+strSize.cx+2*m_Border_Lhs;
        
        DrawLegendElement(pDC, LineLength, LineToText, xpos, ypos, "Output Detector", CLR_DET_OUTPUT);                          ypos += ygap;
        DrawLegendElement(pDC, LineLength, LineToText, xpos, ypos, "Flow-Density Detector", CLR_DET_FLOWDENSITY);       ypos += ygap;
        DrawLegendElement(pDC, LineLength, LineToText, xpos, ypos, "Headway Detector", CLR_DET_HEADWAY);                        ypos += ygap;
        DrawLegendElement(pDC, LineLength, LineToText, xpos, ypos, "Composition Detector", CLR_DET_COMPOSITION);        ypos += ygap;

        pDC->TextOut(xpos,ypos,"LC");
        pDC->TextOut(xpos+LineLength+LineToText,ypos,"Lane Change Detector");

        ypos -= 4*ygap; //reset ypos
        strSize = pDC->GetTextExtent("Lane Change Detector");
        xpos += LineLength+LineToText+strSize.cx+2*m_Border_Lhs;

        DrawLegendSegment(pDC, CLR_FEAT_SPEEDLIMIT, HS_DIAGCROSS, FEAT_SPEEDLIMIT, 
                "Speed limit section", 50, LineToText, xpos, ypos);
        ypos += 2*ygap+5;
        DrawLegendSegment(pDC, CLR_FEAT_GRADIENT, HS_VERTICAL, FEAT_GRADIENT, 
                "Gradient section", 5, LineToText, xpos, ypos);

}

void CEvolveTrafficView::DrawLegendVehicle(CMemDC *pDC, WORD VehType, CString str, int LineToText, int xpos, int ypos)
{       
        int rectWidth = 20/m_Scale;
        int rectHeight = 10/m_Scale;
        
        CSize strSize = pDC->GetTextExtent(str);
        pDC->TextOut(xpos+rectWidth+LineToText, ypos,str);      
        ypos += strSize.cy/2 - rectHeight/2;
        CRect VehRect(xpos,ypos,xpos+rectWidth, ypos+rectHeight);
        DrawVehicleAt(pDC, VehType, VehRect);
}

void CEvolveTrafficView::DrawLegendSegment(CMemDC *pDC, COLORREF COL, WORD HATCH, 
                                                                                   WORD FeatType, CString str, int value, int LineToText, int xpos, int ypos)
{
        int rectWidth = 80/m_Scale;
        int rectHeight = 30/m_Scale;
        
        CRect segRect(xpos,ypos,xpos+rectWidth, ypos+rectHeight);
        DrawSingleSegment(pDC, COL, HATCH, FeatType, value, segRect, 0);
        
        CSize strSize = pDC->GetTextExtent(str);
        pDC->TextOut(xpos+rectWidth+LineToText, ypos+rectHeight/2-strSize.cy/2,str);
}

void CEvolveTrafficView::DrawLegendElement(CMemDC *pDC, int LineLength, int LineToText, 
                                                                                   int xpos, int ypos, CString str, COLORREF COL)
{               
        CPen DetPen;
        
        DetPen.CreatePen(PS_SOLID, 3, COL);
        pDC->SelectObject(&DetPen);
        CSize strSize = pDC->GetTextExtent(str);
        pDC->TextOut(xpos+LineLength+LineToText,ypos,str);
        ypos += strSize.cy/2;
        pDC->MoveTo(xpos,ypos); 
        pDC->LineTo(xpos+LineLength,ypos);
}

void CEvolveTrafficView::DrawRoadSegments(CMemDC *pDC)
{
        CObArray vSeg;  vSeg.Copy( *(m_pDoc->getRoadFeatures()) );
        for(int i = 0; i < vSeg.GetSize(); i++)
        {
                CRoadFeature* pFeat = reinterpret_cast<CRoadFeature*>(vSeg.GetAt(i));
                WORD FeatType = pFeat->getType();
                int FeatValue = 0;
                COLORREF COL;
                WORD HATCH;
                switch(FeatType)
                {
                        case FEAT_SPEEDLIMIT:
                                COL = CLR_FEAT_SPEEDLIMIT;
                                HATCH = HS_DIAGCROSS;
                                FeatValue = Round(pFeat->getValue()*M_PER_S_TO_KM_PER_H);
                                break;
                        case FEAT_GRADIENT:
                                COL = CLR_FEAT_GRADIENT;
                                HATCH = HS_VERTICAL;
                                FeatValue = Round(pFeat->getValue());
                                break;
                        default:
                                COL = CLR_FEAT_SPEEDLIMIT;
                }

                bool DirPos = pFeat->getDirPos();
                int DriveSide = m_DriveOnRight ? +1 : -1;
                int DirFactor = DirPos ? +1 : -1;
                int nLanes = DirPos ? m_NoLanesDirPos : m_NoLanesDirNeg;
                
                int x1 = pFeat->getStart() + m_Border_Lhs;
                int x2 = pFeat->getEnd() + m_Border_Lhs;
                int y1 = 0;
                int y2 = DirFactor * DriveSide * nLanes * m_LaneWidth;
                CRect segRect(x1,y1,x2,y2);
                DrawSingleSegment(pDC, COL, HATCH, FeatType, FeatValue, segRect,m_LaneWidth/2);
        }
}

void CEvolveTrafficView::DrawSingleSegment(CMemDC *pDC, COLORREF COL, WORD HATCH, 
                                                                                   WORD FeatType, int val, CRect rect, int yTextOffset)
{
        int x1 = rect.left;
        int x2 = rect.right;
        int y1 = rect.top;
        int y2 = rect.bottom;

        CPen SegEdgePen(PS_SOLID, 1, COL);
        CPen* pOldPen = pDC->SelectObject(&SegEdgePen);         // store previous pen
        CBrush SegBrush(HATCH,COL);
        CRect SegRect(x1,y1,x2,y2);
        CBrush* pOldBrush = pDC->SelectObject(&SegBrush);       // select drawing object and store previous one
        pDC->SetBkMode(TRANSPARENT);    // set background mode
        pDC->Rectangle(SegRect);                // draw a rectangle which will be patterned //FillRect(SegRect,&SegBrush);
        pDC->SelectObject(pOldBrush);   // reset previous objects
        
        CPen SegEndsPen(PS_SOLID, 3, COL);      // MAGIC NUMBER - seg pen width - keep same as detector pen width
        pDC->SelectObject(&SegEndsPen);
        pDC->MoveTo(x1,y1);     pDC->LineTo(x1,y2);
        pDC->MoveTo(x2,y1);     pDC->LineTo(x2,y2);
        
        pDC->SelectObject(pOldPen);                     // now reselect old pen
        
        CString str; 
        switch(FeatType)
        {
                case FEAT_SPEEDLIMIT:
                        str.Format("%d km/h",val);
                        break;
                case FEAT_GRADIENT:
                        str.Format("%d%%",val);
                        break;
                default:
                        str.Format("%d km/h",val);
        }
        CSize strSize = pDC->GetTextExtent(str);
        pDC->TextOut((x1+x2)/2-strSize.cx/2,(y1+y2)/2-strSize.cy/2+yTextOffset,str);
}

void CEvolveTrafficView::DrawDetectors(CMemDC *pDC)
{
        // Output Detectors
        double LocDetDirPos = m_pDoc->getLocOutputDetectorDirPos();
        double LocDetDirNeg = m_pDoc->getLocOutputDetectorDirNeg();
        DrawSingleDetector(pDC, CLR_DET_OUTPUT, LocDetDirPos, true);
        DrawSingleDetector(pDC, CLR_DET_OUTPUT, LocDetDirNeg, false);

        // Metrics Detectors
        CObArray vSD;   vSD.Copy( *(m_pDoc->getStatDetectors()) );
        for(int i = 0; i < vSD.GetSize(); i++)
        {
                CStatDetector* pSD = reinterpret_cast<CStatDetector*>(vSD.GetAt(i));
                WORD SDtype = pSD->getDetectorType();
                bool bDraw = true;
                COLORREF COL;
                switch(SDtype)
                {
                        case METRICS_TYPE_FLOWDENSITY:  
                                COL = CLR_DET_FLOWDENSITY;
                                break;
                        case METRICS_TYPE_HEADWAY:              
                                COL = CLR_DET_HEADWAY;
                                break;
                        case METRICS_TYPE_COMPOSITION:  
                                COL = CLR_DET_COMPOSITION;
                                break;
                        case METRICS_TYPE_LANE_CHANGE:  // nothing to draw!
                                DrawLaneChangeDetectors(pDC, pSD->getDirPos());
                                bDraw = false;
                                break;
                        default:                                                
                                COL = CLR_DET_FLOWDENSITY;
                }
                if(bDraw)
                        DrawSingleDetector(pDC, COL, pSD->getLocation(), pSD->getDirPos());
        }
}

void CEvolveTrafficView::DrawLaneChangeDetectors(CMemDC *pDC, bool DirPos)
{
        CString str = "LC";
        CSize strSize = pDC->GetTextExtent(str);
        
        int DriveSide = m_DriveOnRight ? +1 : -1;
        int DirFactor = DirPos ? +1 : -1;
        int nLanes = DirPos ? m_NoLanesDirPos : m_NoLanesDirNeg;

        int xScrnLoc = m_Border_Lhs - strSize.cx - 2;
        int ypos = DirFactor* DriveSide * nLanes * m_LaneWidth /2;

        pDC->TextOut(xScrnLoc,ypos-strSize.cy/2,str);
}

void CEvolveTrafficView::DrawSingleDetector(CMemDC *pDC, COLORREF COL, int Loc, bool DirPos)
{
        // Draw detectors
        CPen DetectorPen(PS_SOLID, 3, COL);     // MAGIC NUMBER - detector pen width
        pDC->SelectObject(&DetectorPen);

        int ScrnLoc = Loc + m_Border_Lhs;

        int DriveSide = m_DriveOnRight ? +1 : -1;
        int DirFactor = DirPos ? +1 : -1;
        int nLanes = DirPos ? m_NoLanesDirPos : m_NoLanesDirNeg;

        int ypos = 0;//DirFactor*DriveSide*m_RoadWidth/2;// + m_ClientRect.Height()/2;  // bottom/top of road
        pDC->MoveTo(ScrnLoc,ypos);                                                                                              // start at bottom/top
        //ypos = ypos - DirFactor* DriveSide * nLanes * m_LaneWidth;                            // distance to top/bottom
        ypos = DirFactor* DriveSide * nLanes * m_LaneWidth;
        pDC->LineTo(ScrnLoc,ypos);                                                                                              // draw line
}

void CEvolveTrafficView::DrawRuler(CMemDC *pDC)
{
        int ypos = m_BtmEdge;

        //int ypos =    m_YCoordTop; //m_ClientRect.Height()/2 + m_RoadWidth/2;
        CPen RulerLinesPen(PS_SOLID, 0, CLR_RULER_LINES);
        pDC->SelectObject(&RulerLinesPen);
        pDC->SetTextColor(CLR_RULER_TEXT);
        pDC->SetBkColor(CLR_BACKGRND);

        for(int i = 0; i < m_NoTicks; i++)
        {
                int xpos = m_Border_Lhs+i*m_TickStep;
                pDC->MoveTo(xpos,ypos);
                pDC->LineTo(xpos,ypos+m_TickLength);
                CString str; str.Format("%d m",i*m_TickStep);
                pDC->TextOut(xpos+5,ypos+10,str);
        }
}

---