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

Go to the documentation of this file.

// LaneChangeDetector.cpp: implementation of the LaneChangeDetector class.
//

#include "stdafx.h"
#include "LaneChangeDetector.h"

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

// Construction/Destruction

LaneChangeDetector::LaneChangeDetector(std::string dir, double dt, double dx, int roadLen,
                                                                           bool DirPos, WORD VehType)
{
        m_MetricsDir = dir; 
        m_TimeInterval = dt;
        m_DistanceInterval = dx;
        m_RoadLength = roadLen;
        m_DirPos = DirPos;
        m_VehicleType = VehType;
        
        m_NoLaneChangeEvents = 0;
        m_DetectorType = METRICS_TYPE_LANE_CHANGE;

        int curPos = 0;
        while(curPos < m_RoadLength)
        {
                m_vDistanceIntervals.push_back(curPos);
                curPos += m_DistanceInterval;
        }
        m_vDistanceIntervals.push_back(m_RoadLength); // enclose the last interval
        m_NoDistIntervals = m_vDistanceIntervals.size();
        m_vDistInt_LCECount.assign(m_NoDistIntervals, 0);

        InitOutputFiles();
}

LaneChangeDetector::~LaneChangeDetector()
{

}

void LaneChangeDetector::InitOutputFiles()
{       
        if(m_VehicleType == METRICS_VEH_ALL)
                InitCompositionFile();  // only makes sense for all vehicles
        
        InitVerboseFile();
        InitSpaceTimeFile();
        InitRateFile();
}

void LaneChangeDetector::addEvent(LaneChangeEvent* pLCE)
{
        WORD vehID = pLCE->getVehicleType();
        
        switch(m_VehicleType)
        {
                case METRICS_VEH_ALL:                   
                        AddCurrentEvent(pLCE);
                        break;
                case METRICS_VEH_CAR:
                        if(vehID == VEH_ID_CAR)
                                AddCurrentEvent(pLCE);
                        break;
                case METRICS_VEH_SMALLTRUCK:
                        if(vehID == VEH_ID_SMALLTRUCK)
                                AddCurrentEvent(pLCE);
                        break;
                case METRICS_VEH_LARGETRUCK:
                        if(vehID == VEH_ID_LARGETRUCK)
                                AddCurrentEvent(pLCE);
                        break;
                case METRICS_VEH_CRANE:
                        if(vehID == VEH_ID_CRANE)
                                AddCurrentEvent(pLCE);
                        break;
                case METRICS_VEH_LOWLOADER:
                        if(vehID == VEH_ID_LOWLOADER)
                                AddCurrentEvent(pLCE);
                        break;
                default:
                        AddCurrentEvent(pLCE);
        }
}

void LaneChangeDetector::AddCurrentEvent(LaneChangeEvent* lce)
{
        m_vChangeEvents.push_back(lce);
        m_NoLaneChangeEvents++;
}

void LaneChangeDetector::doIntervalOutput()
{
        doVerboseOutput();
        doCompositionOutput();
        doSpaceTimeOutput();
        doRateOutput();

        ReInit();
}

void LaneChangeDetector::EndOutput()
{
        if(m_VehicleType == METRICS_VEH_ALL)
                m_OutFile_Composition.close();

        m_OutFile_Verbose.close();
        m_OutFile_SpaceTime.close();
        m_OutFile_Rate.close();
}

void LaneChangeDetector::ReInit()
{
        m_NoLaneChangeEvents = 0;

        m_vDistInt_LCECount.clear();
        m_vDistInt_LCECount.assign(m_NoDistIntervals, 0);

        for(int i = 0; i < m_vChangeEvents.size(); i++)
                delete m_vChangeEvents.at(i);
        m_vChangeEvents.clear();

}

void LaneChangeDetector::InitVerboseFile()
{
        std::string file;
        file = m_MetricsDir;
        file += "LC_All_" + MapDetVehTypeToString(m_VehicleType) + "_" 
                                     + MapDirToString(m_DirPos) + ".csv";

        m_OutFile_Verbose.open(file.c_str(), std::ios::out);

        m_OutFile_Verbose << "LANE CHANGE - VERBOSE OUTPUT OF EVENTS" << '\n';
        m_OutFile_Verbose << "Time,";
        m_OutFile_Verbose << "Position,";
        m_OutFile_Verbose << "From Lane,";
        m_OutFile_Verbose << "To Lane,";
        m_OutFile_Verbose << "Right/Left,";
        m_OutFile_Verbose << "Type" << '\n';
        m_OutFile_Verbose << std::endl;
}

void LaneChangeDetector::InitCompositionFile()
{
        std::string file;
        file = m_MetricsDir;
        file += "LC_Comp_" + MapDetVehTypeToString(m_VehicleType) + "_" 
                                      + MapDirToString(m_DirPos) + ".csv";

        m_OutFile_Composition.open(file.c_str(), std::ios::out);

        m_OutFile_Composition << "LANE CHANGE - COMPOSITION OF EVENTS" << "\n";
        m_OutFile_Composition << "Time Interval"        << ",";
        m_OutFile_Composition << "Car Changes"          << ",";
        m_OutFile_Composition << "SmallTr Changes"      << ","; 
        m_OutFile_Composition << "LargeTr Changes"      << ","; 
        m_OutFile_Composition << "Crane Changes"        << ","; 
        m_OutFile_Composition << "LowLoad Changes"      << '\n'; 

}

void LaneChangeDetector::InitSpaceTimeFile()
{
        std::string file;
        file = m_MetricsDir;
        file += "LC_ST_" + MapDetVehTypeToString(m_VehicleType) + "_" 
                                    + MapDirToString(m_DirPos) + ".csv";
        
        m_OutFile_SpaceTime.open(file.c_str(), std::ios::out);

        m_OutFile_SpaceTime << "LANE CHANGE - SPACE TIME OF EVENTS" << '\n';
        m_OutFile_SpaceTime << "Left To Right," << ',' << "Right To Left" << '\n';
        m_OutFile_SpaceTime << "Time (s),Location (m),Time (s),Location (m)" << '\n';
}

void LaneChangeDetector::InitRateFile()
{
        std::string file;
        file = m_MetricsDir;
        file += "LC_Rate_" + MapDetVehTypeToString(m_VehicleType) + "_" 
                                      + MapDirToString(m_DirPos) + ".csv";
        
        m_OutFile_Rate.open(file.c_str(), std::ios::out);

        m_OutFile_Rate << "LANE CHANGE - RATES BY LOCATION AND TIME" << '\n';
        m_OutFile_Rate << "Time (s),Location (m)" << '\n';
        m_OutFile_Rate << ",";
        for(int i = 0; i < m_NoDistIntervals; i++)
                m_OutFile_Rate << m_vDistanceIntervals[i] << ",";
        m_OutFile_Rate << '\n';
}

void LaneChangeDetector::doVerboseOutput()
{
        for(int i = 0; i < m_NoLaneChangeEvents; i++)
        {
                LaneChangeEvent* curEvent = m_vChangeEvents.at(i);

                std::string change = (curEvent->getChangeLeft()) ? "Left" : "Right";
                std::string dir = (curEvent->getDirPos()) ? "Pos" : "Neg";

                std::string type;

                switch(curEvent->getVehicleType())
                {
                        case VEH_ID_CAR:                type = "Car";           break;
                        case VEH_ID_SMALLTRUCK: type = "SmallTr";       break;
                        case VEH_ID_LARGETRUCK: type = "LargeTr";       break;
                        case VEH_ID_CRANE:              type = "Crane";         break;
                        case VEH_ID_LOWLOADER:  type = "Lowload";       break;
                }

                m_OutFile_Verbose << curEvent->getTime() << " ," 
                                                  << curEvent->getPosition()            << " ," 
                                                  << curEvent->getOriginLane()          << " ,"
                                                  << curEvent->getDestinationLane()     << " ," 
                                                  << change                                                     << " ," 
                                                  << type << '\n';
        }
}

void LaneChangeDetector::doCompositionOutput()
{
        int nCar = 0;
        int nSmallTruck = 0;
        int nLargeTruck = 0;
        int nCrane = 0;
        int nLowLoader = 0;

        for(int i = 0; i < m_NoLaneChangeEvents; i++)
        {
                WORD VehType = m_vChangeEvents.at(i)->getVehicleType();

                switch(VehType)
                {
                        case VEH_ID_CAR:                nCar++;                 break;
                        case VEH_ID_SMALLTRUCK: nSmallTruck++;  break;
                        case VEH_ID_LARGETRUCK: nLargeTruck++;  break;
                        case VEH_ID_CRANE:              nCrane++;               break;
                        case VEH_ID_LOWLOADER:  nLowLoader++;   break;
                        default: nCar++; 
                }
        }       

        m_OutFile_Composition << m_TotalTime    << ",";
        m_OutFile_Composition << nCar                   << ",";
        m_OutFile_Composition << nSmallTruck    << ","; 
        m_OutFile_Composition << nLargeTruck    << ","; 
        m_OutFile_Composition << nCrane                 << ","; 
        m_OutFile_Composition << nLowLoader             << '\n';
}

void LaneChangeDetector::doSpaceTimeOutput()
{
        for(int i = 0; i < m_NoLaneChangeEvents; i++)
        {
                LaneChangeEvent* pLCE = m_vChangeEvents.at(i);
                double time                     = pLCE->getTime();
                double position         = pLCE->getPosition();
                bool bChangeToLeft      = pLCE->getChangeLeft();

                if(bChangeToLeft)               // send to right hand column
                        m_OutFile_SpaceTime << ",,";
                
                m_OutFile_SpaceTime << time << ',' << position << '\n';
        }
}

void LaneChangeDetector::doRateOutput()
{
        for(int i = 0; i < m_NoLaneChangeEvents; i++)
        {
                double position = m_vChangeEvents.at(i)->getPosition();
                int iDistInterval = 0;
                // find the interval to be incremented
                while( !(position < m_vDistanceIntervals[iDistInterval]) )
                        iDistInterval++;

                m_vDistInt_LCECount[iDistInterval]++;   // count it
        }
        
        double deltaX = (double)m_DistanceInterval/1000;                // change to km
        double deltaT = (double)m_TimeInterval/SECS_PER_HOUR;   // change to hour
        
        m_OutFile_Rate << m_TotalTime;
        for(i = 0; i < m_NoDistIntervals; i++)
        {
                double n = m_vDistInt_LCECount[i];
                double rate = n/(deltaX*deltaT);
                m_OutFile_Rate << ',' << rate;
        }
        m_OutFile_Rate << '\n';
}

---