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

Go to the documentation of this file.

#include "stdafx.h"
#include "Direction.h"

Direction::Direction()
{
        m_pOutputDetector = NULL;
}

Direction::~Direction()
{
        int i;

        // Delete all of this direction's metrics detectors
        for(i = 0; i < m_vDetectors.size(); i++)
                delete m_vDetectors.at(i);


        // Delete all of this direction's special segments
        for(i = 0; i < m_vRoadSegments.size(); i++)
                delete m_vRoadSegments.at(i);

}

bool Direction::update(const double step, const double curTime)
{
        CheckDetectorTimes(step);       // check if it's time to output what we have
        bool DirectionEmpty = false;
        int NoEmptyLanes = 0;
        for(int i = 0; i < m_NoLanes; i++)
        {
                bool laneEmpty = m_vLanes[i].update(step, curTime);
                if(laneEmpty)
                        NoEmptyLanes++;
        }
        
        // output any vehicles past the detector
        m_pOutputDetector->WriteVehiclesToFile();

        if(NoEmptyLanes == m_NoLanes)
                DirectionEmpty = true;

        return DirectionEmpty;
}

void Direction::init(bool DirPos, OutputDetector* pOutDet, bool AllowLaneChange, int RoadLength, bool DriveOnRight)
{
        m_DirPos = DirPos;
        m_pOutputDetector = pOutDet;
        m_AllowLaneChanging = AllowLaneChange;
        m_RoadLength = RoadLength;
        m_DriveOnRight = DriveOnRight;
}

void Direction::createLanes(int iFirstLane, std::vector<int> vLaneLengths, std::vector<Detector*> detectors, 
                                                        std::vector<RoadSegment*> segments)
{
        m_NoLanes = vLaneLengths.size();
        m_vDetectors = detectors;
        m_vRoadSegments = segments;

        for(int i = 0; i < m_NoLanes; i++)
        {
                Lane lane(iFirstLane + i, vLaneLengths[i], m_vDetectors, m_DirPos, m_AllowLaneChanging);
                lane.setOutputDetector(m_pOutputDetector);
                lane.setRoadSegments(m_vRoadSegments);
                m_vLanes.push_back(lane);
        }

        // set adjacent lanes if more than 1 lane
        if(m_NoLanes > 1)
        {
                // If(DRIVE_ON_RIGHT), lanes are numbered from the BTM of the screen as:
                // Dir Pos - 0, 1, 2, 3 -  Dir Neg - 4, 5, 6, 7
                // else lanes are numbered from the TOP of the screen
                if(m_DriveOnRight)
                {
                        for(i = 0; i < m_NoLanes - 1; i++)
                                m_vLanes.at(i).setLeftLane(&m_vLanes.at(i+1));  // next lane up the screen
                        for(i = 1; i < m_NoLanes; i++)
                                m_vLanes.at(i).setRightLane(&m_vLanes.at(i-1)); // one down the screen
                }
                else
                {
                        for(i = 0; i < m_NoLanes - 1; i++)
                                m_vLanes.at(i).setRightLane(&m_vLanes.at(i+1)); // next lane down the screen
                        for(i = 1; i < m_NoLanes; i++)
                                m_vLanes.at(i).setLeftLane(&m_vLanes.at(i-1));  // next one up the screen
                }
        }
}

M2D Direction::getGlobalPos()
{
        // this modifies the lane position to take accound of direction
        M2D vVeh2D = getVehiclesM2D();

        if(!m_DirPos)   // if in negative x-direction
        {
                for(int i = 0; i < m_NoLanes; i++)
                {
                        int d2 = vVeh2D[i].size();
                        for(int j = 0; j < d2; j++)
                                vVeh2D[i][j]->setRoadPos( m_vLanes[i].getLength() - vVeh2D[i][j]->getPos() );
                }
        }
        return vVeh2D;
}

M2D Direction::getVehiclesM2D()
{
        // returns vehicles for position from the start of the lane extraction
        M2D vVeh2D;

        for(int i = 0; i < m_NoLanes; i++)
        {
                std::vector<Vehicle*> temp = m_vLanes[i].getPos();
                vVeh2D.push_back(temp);
        }
        return vVeh2D;
}

int Direction::getNoLanes()
{
        return m_NoLanes;
}

Lane& Direction::getLane(int i)
{
        return m_vLanes.at(i);
}

OutputDetector* Direction::getOutputDetector()
{
        return m_pOutputDetector;
}

void Direction::setOutputDetector(OutputDetector *OutputDet)
{
        m_pOutputDetector = OutputDet;
}

void Direction::CheckDetectorTimes(double step)
{
        for(int i = 0; i < m_vDetectors.size(); i++)
        {
                m_vDetectors.at(i)->CheckForOutputTime(step);
        }
}
void Direction::clear()
{
        int i;

        for(i = 0; i < m_vLanes.size(); i++)
                m_vLanes.at(i).clear();

        m_vLanes.clear();

        delete m_pOutputDetector; // Delete this direction's output detector

        // Delete all of this direction's metrics detectors
        for(i = 0; i < m_vDetectors.size(); i++)
                delete m_vDetectors.at(i);

        m_vDetectors.clear();

        // Delete all of this direction's special segments
        for(i = 0; i < m_vRoadSegments.size(); i++)
                delete m_vRoadSegments.at(i);

        m_vRoadSegments.clear();
}

---