Traffic-Network-Model

     for (int i = 0; i < 8; i++) {

        for (int j = 0; j < 8; j++) {

            status[i][j] = false;

        }

    }

status[2][1] = status[4][3] = true;

status[0][1] = status[2][3] = status[4][5] = true;

// 出口不能自转和变道

status[0][0] = status[0][2]  = status[0][4]  = false;

status[4][4] = status[4][0]  = status[4][2]  = false;

status[2][2] = status[2][0]  = status[2][4]  = false;

// 出口不能进去

status[1][0] =status[1][4]  = status[1][2] = status[1][3]   = status[1][4] = status[1][5] = false;

status[3][0] =status[3][5]  = status[3][2] = status[3][3]   = status[3][4] = status[3][5] = false;

status[5][0] =status[5][6]  = status[5][2] = status[5][3]   = status[5][4] = status[5][5] = false;

for (int V_begin = 0; V_begin < G->m_CrossRoad_v.size(); V_begin++) {

}

vector<double> Determined_dist(G->m_CrossRoad_v.size(), 0.0);

void calcShortestPath(Graph *G) {

    int currentPointSite,nextPointSite;

    ofstream PointPathFile(DIR_RES"PointPath.txt"),RoadPathFile(DIR_RES"RoadPath.txt");

    //对点进行的一级遍历

    for (int V_begin = 0; V_begin < G->m_CrossRoad_v.size(); V_begin++) {

        // =================== 迪杰斯特拉算法开始 ===============================

        vector<bool> S(G->m_CrossRoad_v.size(), false); //判断是否选中

        vector<double> dist(G->m_CrossRoad_v.size(), DBL_MAX/2);// dist

        vector<double> compare_dist(G->m_CrossRoad_v.size(), DBL_MAX/2);// 辅助dist用来取最短距离点

        vector<int> path(G->m_CrossRoad_v.size(),-2); // path

        S[V_begin] = true;

        path[V_begin] = -1;

        for(auto crossroad : G->m_CrossRoad_v[V_begin].JunctionRoad){

            nextPointSite = G->m_Road_v[crossroad.outRoadID].m_CrossRoadToSite;

            dist[nextPointSite] = G->m_Road_v[crossroad.outRoadID].m_dLength;

            compare_dist[nextPointSite] = dist[nextPointSite];

        }

        auto min = min_element(compare_dist.begin(), compare_dist.end());

        int min_element_index = distance(compare_dist.begin(), min);

        compare_dist[min_element_index] = DBL_MAX/2;

        // 循环size-1次

        for(int i = 0; i < G->m_CrossRoad_v.size()-1; i++){

            for(auto crossroad : G->m_CrossRoad_v[min_element_index].JunctionRoad){

                currentPointSite = min_element_index;

                nextPointSite = G->m_Road_v[crossroad.outRoadID].m_CrossRoadToSite;

                if(S[nextPointSite]){

                    continue;

                }

                if(dist[nextPointSite] > dist[currentPointSite] + G->m_Road_v[crossroad.outRoadID].m_dLength) {

                    dist[nextPointSite] = dist[currentPointSite] + G->m_Road_v[crossroad.outRoadID].m_dLength;

                    compare_dist[nextPointSite] = dist[nextPointSite];

                    path[nextPointSite] = currentPointSite;

                }

            }

            min = min_element(compare_dist.begin(), compare_dist.end());

            min_element_index = distance(compare_dist.begin(), min);

            S[min_element_index] = true;

            compare_dist[min_element_index] = DBL_MAX/2;

        }

        for(int i = 0;i<path.size();i++){

            int j = i;

            bool flag = false;

            while( path[j] >= 0) {

                flag = true;

                PointPathFile << path[j] << " ";

                for(auto node:G->m_CrossRoad_v[j].JunctionRoad){

                    if(G->m_Road_v[node.outRoadID].m_CrossRoadToSite == path[j]){

                        RoadPathFile << node.outRoadID << " ";

                    }

                }

                j = path[j];

            }

            if(flag){RoadPathFile << endl;PointPathFile << endl ;}

        }

    }

}

<?xml version='1.0' encoding='UTF-8'?>

<Roads>

  <road m_ID="71283896--1" len="620.98">

    <from lon="113.9205606" lat="22.9317667" id="848388981"/>

    <to lon="113.9260573" lat="22.9341232" id="2522072722"/>

  </road>

  <road m_ID="553852656--2" len="322.34">

    <from lon="113.9529339" lat="22.9448978" id="5345735265"/>

    <to lon="113.9516926" lat="22.9475618" id="5345735267"/>

  </road>

</Roads>

/**

*  路口类，记录着该路口的点坐标，以及其相连的方向道路节点组

 *               |           |

 *               |     |     |

 *               |  1     2  |

 *               |     |     |

 *        --------           --------

 *           3                  5

 *        - - - -            - - - -

 *           4                  6

 *        --------           --------

 *               |     |     |

 *               |  7     8  |

 *               |     |     |

 *               |           |

 *    如上图(1,2), (3,4), (5,6), (7,8)在同一个方向,我将其称为四组方向道路节点Node.

 *    其中,Node.inRoadID=1, Node.outRoadID=2;

 *         Node.inRoadID=4, Node.outRoadID=3;

 *         ...

 *         根据车辆靠右行原则以此类推.

*/

class CrossRoad {

public:

    CrossRoad(float fLon,float fLat) : m_fLat(fLat),m_fLon(fLon){};

    /**

     * 重载运算符 （==） 判断两个路口是否为同一个

     */

    bool operator==(CrossRoad &crossRoad);

    /**

     * 添加道路节点ID

     * @param in 入度

     * @param out 出度

     * @param atan2 该点与方向道路的atan2值

     */

    void addNode(int in,int out,double atan2);

public:

    //唯一标示符

    int m_nID;

    //经纬度的定义

    float m_fLon, m_fLat;

    vector<Node> JunctionRoad;

    //该路口的交通灯

    TrafficLight m_CTrafficLight_Light;

};

generateVehicle(Map_Graph);

std::random_device rd;

std::mt19937 mt(rd());

Vehicle car(n_VehicleNum, route, 0, 0, route.front());

G.m_Road_v[route.front()].m_queVehicle.push_back(car);

runSimulation(Graph &G)

  for (auto &road:G.m_Road_v) {

        auto src = road.m_queVehicle;

        decltype(road.m_queVehicle) obj;

        //路内车的遍历

        while (!src.empty()) {

            //弹出一辆车

            auto it = src.front();

            src.pop_front();

            // 当车的时间戳小于实际时间时，才模拟运行

            if (it.time < SYSTEM_TIME) {

                it.fSpec = (100 - road.get_Congestion() - 20) / 3.6;

                dist = it.dDistance + it.fSpec * 10;

                it.time++;



                it.showself();

                //如果车十秒后不在此路

                if (dist >= road.m_dLength) {

                    //路径擦除

                    auto route = it.queRoute;

                    int site = it.m_nSiteRoadID;

                    route.pop();

                    //如果抵达终点

                    if (route.empty()) {

                        cout << "it is be shutdown" << endl;

                        exit(0);

                        // 否侧没有抵达终点

                    } else {

                        //获取所在路和下一条路的ID

                        int next = route.front();

                        //判断红绿灯情况

                        cout << site << endl;

                        G.m_CrossRoad_v[site].m_CTrafficLight_Light.clock(SYSTEM_TIME);

                        //如果可以通行

                        if (G.m_CrossRoad_v[site].m_CTrafficLight_Light.getStatus(it.m_nSiteRoadID, next)) {

                            cout << GREEN << "绿灯通行:" << endl;

                            it.queRoute = route;

                            it.dDistance = 0;

                            it.m_nSiteRoadID = next;

                            auto *site_road = &G.m_Road_v[next].m_queVehicle;

                            site_road->push_back(it);

                            //如果不能通行

                        } else {

                            //将距离置为道路长度，表示正在等候红灯

                            it.dDistance = G.m_Road_v[it.m_nSiteRoadID].m_dLength;

                            cout << YELLOW << "等待红灯" << endl;

                            //车辆塞回去

                            obj.push_back(it);

                        }

                    }

                    //否则，当车十秒后还在此路时

                } else {

                    it.dDistance = dist;

                    obj.push_back(it);

                }

                //否则直接填入

            } else {

                obj.push_back(it);

            }

        }

        road.m_queVehicle = obj;

    }

vector<queue<int>> v_Route;



/**

 * load route from route file

 * @param Map_graph

 */

void loadRoute(Graph &Map_graph) {

    string str_Path;

    ifstream fin_Route(DIR_RES"route.txt");

    while (getline(fin_Route, str_Path)) {

        stringstream ss_Temp(str_Path);

        queue<int> q_Path_Temp;

        int n_Temp;

        while (ss_Temp >> n_Temp) {

            q_Path_Temp.push(n_Temp);

        }

        v_Route.push_back(q_Path_Temp);

    }

}

it->m_CTrafficLight_Light.setType(it->JunctionRoad.size());

/**

 * 交通灯类

 */

class TrafficLight {

public:

    TrafficLight() {

        for (int i = 0; i < 8; i++) {

            roadID[i] = -1;

        }



    };

    void changeStatus();



    void clock(int time);



    void setAllRed();



    void setAllGreen();



    bool getStatus(int from, int to);

    /**

     * 设置灯的类型, 是T字路口还是+字路口

     * @param type 

     */

    void setType(int type) { this->type = type; };

    //路口标号

    // nLeftIn,nLeftOut,nDownIn,nDownOut,nRightIn,nRightOut,nUpIn,nUpOut;

    int roadID[8];

    //路口是否能走通

    bool status[4][4] = {false};

    int type;

    //表示可通过的方向（目标方向）

    //AllRED = 0,LeftGreen = 1,DownGreen = 2,RightGreen = 3,UpGreen = 4,UpDownGreen = 5,LeftRightGreen = 6,cross1 = 7,cross2 = 8

    int emStatus = 0;

    long long int time = 0;

};