// ------------------------------------------------------------------------- int GraphDefinition:: my_dijkstra(edge_t *edges, unsigned int edge_count, int start_vertex, int end_vertex, bool directed, bool has_reverse_cost, path_element_t **path, int *path_count, char **err_msg, std::vector<PDVI> &ruleList) { m_ruleTable.clear(); int total_rule = ruleList.size(); int i; LongVector vecsource; unsigned int kk; for(i = 0; i < total_rule; i++) { Rule rule; rule.cost = ruleList[i].first; int j; int seq_cnt = ruleList[i].second.size(); for(j = 1; j < seq_cnt; j++) { rule.precedencelist.push_back(ruleList[i].second[j]); } int dest_edge_id = ruleList[i].second[0]; if(m_ruleTable.find(dest_edge_id) != m_ruleTable.end()) { m_ruleTable[dest_edge_id].push_back(rule); } else { std::vector<Rule> temprules; temprules.clear(); temprules.push_back(rule); m_ruleTable.insert(std::make_pair(dest_edge_id, temprules)); } if(isStartVirtual) { if(seq_cnt == 2 && ruleList[i].second[1] == m_lStartEdgeId) { vecsource = m_mapNodeId2Edge[start_vertex]; for(kk = 0; kk < vecsource.size(); kk++) { rule.precedencelist.clear(); rule.precedencelist.push_back(m_vecEdgeVector[vecsource[kk]]->m_lEdgeID); m_ruleTable[dest_edge_id].push_back(rule); } } } } if(isEndVirtual) { if(m_ruleTable.find(m_lEndEdgeId) != m_ruleTable.end()) { std::vector<Rule> tmpRules = m_ruleTable[m_lEndEdgeId]; vecsource = m_mapNodeId2Edge[end_vertex]; for(kk = 0; kk < vecsource.size(); kk++) { m_ruleTable.insert(std::make_pair(m_vecEdgeVector[vecsource[kk]]->m_lEdgeID, tmpRules)); } } } m_bIsturnRestrictOn = true; return(my_dijkstra(edges, edge_count, start_vertex, end_vertex, directed, has_reverse_cost, path, path_count, err_msg)); }
// ------------------------------------------------------------------------- int GraphDefinition::multi_dijkstra( edge_t *edges, size_t edge_count, std::vector<int> vertices, bool directed, bool has_reverse_cost, path_element_tt **path, size_t *path_count, char **err_msg, std::vector<PDVI> &ruleList) { construct_graph(edges, edge_count, has_reverse_cost, directed); if (ruleList.size() > 0) { m_ruleTable.clear(); LongVector vecsource; for (const auto &rule : ruleList) { std::vector<long> temp_precedencelist; temp_precedencelist.clear(); for (auto const &seq : rule.second) { temp_precedencelist.push_back(seq); } long dest_edge_id = rule.second[0]; if (m_ruleTable.find(dest_edge_id) != m_ruleTable.end()) { m_ruleTable[dest_edge_id].push_back(Rule(rule.first, temp_precedencelist)); } else { std::vector<Rule> temprules; temprules.clear(); temprules.push_back(Rule(rule.first, temp_precedencelist)); m_ruleTable.insert(std::make_pair(dest_edge_id, temprules)); } } m_bIsturnRestrictOn = true; } parent = new PARENT_PATH[edge_count + 1]; m_dCost = new CostHolder[edge_count + 1]; m_vecPath.clear(); size_t i; size_t total_vertices = vertices.size(); for (i = 0; i < total_vertices - 1; i++) { int ret = my_dijkstra(vertices[i], vertices[i + 1], edge_count, err_msg); if (ret < 0) { deleteall(); return -1; } } *path = (path_element_tt *) malloc(sizeof(path_element_tt) * (m_vecPath.size() + 1)); *path_count = static_cast<int>(m_vecPath.size()); for (size_t i = 0; i < *path_count; i++) { (*path)[i].vertex_id = m_vecPath[i].vertex_id; (*path)[i].edge_id = m_vecPath[i].edge_id; (*path)[i].cost = m_vecPath[i].cost; } deleteall(); return 0; }
// ------------------------------------------------------------------------- int GraphDefinition:: my_dijkstra(edge_t *edges, size_t edge_count, long start_vertex, long end_vertex, bool directed, bool has_reverse_cost, path_element_tt **path, size_t *path_count, char **err_msg, std::vector<PDVI> &ruleList) { m_ruleTable.clear(); LongVector vecsource; for (const auto &rule : ruleList) { size_t j; size_t seq_cnt = rule.second.size(); std::vector<long> temp_precedencelist; temp_precedencelist.clear(); for (j = 1; j < seq_cnt; j++) { temp_precedencelist.push_back(rule.second[j]); } long dest_edge_id = rule.second[0]; if (m_ruleTable.find(dest_edge_id) != m_ruleTable.end()) { m_ruleTable[dest_edge_id].push_back(Rule(rule.first, temp_precedencelist)); } else { std::vector<Rule> temprules; temprules.clear(); temprules.push_back(Rule(rule.first, temp_precedencelist)); m_ruleTable.insert(std::make_pair(dest_edge_id, temprules)); } if (isStartVirtual) { if (seq_cnt == 2 && rule.second[1] == m_lStartEdgeId) { vecsource = m_mapNodeId2Edge[start_vertex]; for (const auto &source : vecsource) { temp_precedencelist.clear(); temp_precedencelist.push_back( m_vecEdgeVector[source]->m_lEdgeID); m_ruleTable[dest_edge_id].push_back(Rule(rule.first, temp_precedencelist)); } } } } if (isEndVirtual) { if (m_ruleTable.find(m_lEndEdgeId) != m_ruleTable.end()) { std::vector<Rule> tmpRules = m_ruleTable[m_lEndEdgeId]; vecsource = m_mapNodeId2Edge[end_vertex]; for (const auto &source : vecsource) { m_ruleTable.insert(std::make_pair( m_vecEdgeVector[source]->m_lEdgeID, tmpRules)); } } } m_bIsturnRestrictOn = true; return(my_dijkstra(edges, edge_count, start_vertex, end_vertex, directed, has_reverse_cost, path, path_count, err_msg)); }
// ------------------------------------------------------------------------- int GraphDefinition::my_dijkstra(edge_t *edges, unsigned int edge_count, int start_edge_id, double start_part, int end_edge_id, double end_part, bool directed, bool has_reverse_cost, path_element_t **path, int *path_count, char **err_msg, std::vector<PDVI> &ruleList) { if(!m_bIsGraphConstructed) { init(); construct_graph(edges, edge_count, has_reverse_cost, directed); m_bIsGraphConstructed = true; } GraphEdgeInfo* start_edge_info = m_vecEdgeVector[m_mapEdgeId2Index[start_edge_id]]; edge_t start_edge; int start_vertex, end_vertex; m_dStartpart = start_part; m_dEndPart = end_part; m_lStartEdgeId = start_edge_id; m_lEndEdgeId = end_edge_id; if(start_part == 0.0) { start_vertex = start_edge_info->m_lStartNode; } else if(start_part == 1.0) { start_vertex = start_edge_info->m_lEndNode; } else { isStartVirtual = true; m_lStartEdgeId = start_edge_id; start_vertex = max_node_id + 1; max_node_id++; start_edge.id = max_edge_id + 1; max_edge_id++; start_edge.source = start_vertex; start_edge.reverse_cost = -1.0; if(start_edge_info->m_dCost >= 0.0) { start_edge.target = start_edge_info->m_lEndNode; start_edge.cost = (1.0 - start_part) * start_edge_info->m_dCost; addEdge(start_edge); edge_count++; } if(start_edge_info->m_dReverseCost >= 0.0) { start_edge.id = max_edge_id + 1; max_edge_id++; start_edge.target = start_edge_info->m_lStartNode; start_edge.cost = start_part * start_edge_info->m_dReverseCost; addEdge(start_edge); edge_count++; } } GraphEdgeInfo* end_edge_info = m_vecEdgeVector[m_mapEdgeId2Index[end_edge_id]]; edge_t end_edge; if(end_part == 0.0) { end_vertex = end_edge_info->m_lStartNode; } else if(end_part == 1.0) { end_vertex = end_edge_info->m_lEndNode; } else { isEndVirtual = true; m_lEndEdgeId = end_edge_id; end_vertex = max_node_id + 1; max_node_id++; end_edge.id = max_edge_id + 1; max_edge_id++; end_edge.target = end_vertex; end_edge.reverse_cost = -1.0; if(end_edge_info->m_dCost >= 0.0) { end_edge.source = end_edge_info->m_lStartNode; end_edge.cost = end_part * end_edge_info->m_dCost; addEdge(end_edge); edge_count++; } if(end_edge_info->m_dReverseCost >= 0.0) { end_edge.source = end_edge_info->m_lEndNode; end_edge.id = max_edge_id + 1; end_edge.cost = (1.0 - end_part) * end_edge_info->m_dReverseCost; addEdge(end_edge); edge_count++; } } return(my_dijkstra(edges, edge_count, start_vertex, end_vertex, directed, has_reverse_cost, path, path_count, err_msg, ruleList)); }
// ------------------------------------------------------------------------- int GraphDefinition::multi_dijkstra( edge_t *edges, unsigned int edge_count, std::vector<int> vertices, bool directed, bool has_reverse_cost, path_element_t **path, int *path_count, char **err_msg, std::vector<PDVI> &ruleList) { construct_graph(edges, edge_count, has_reverse_cost, directed); if(ruleList.size() > 0) { m_ruleTable.clear(); int total_rule = ruleList.size(); int i; LongVector vecsource; // int kk; for(i = 0; i < total_rule; i++) { Rule rule; rule.cost = ruleList[i].first; int j; int seq_cnt = ruleList[i].second.size(); for(j = 1; j < seq_cnt; j++) { rule.precedencelist.push_back(ruleList[i].second[j]); } int dest_edge_id = ruleList[i].second[0]; if(m_ruleTable.find(dest_edge_id) != m_ruleTable.end()) { m_ruleTable[dest_edge_id].push_back(rule); } else { std::vector<Rule> temprules; temprules.clear(); temprules.push_back(rule); m_ruleTable.insert(std::make_pair(dest_edge_id, temprules)); } } m_bIsturnRestrictOn = true; } parent = new PARENT_PATH[edge_count + 1]; m_dCost = new CostHolder[edge_count + 1]; m_vecPath.clear(); int i; int total_vertices = vertices.size(); for(i = 0; i < total_vertices - 1; i++) { int ret = my_dijkstra(vertices[i], vertices[i + 1], edge_count, err_msg); if(ret < 0) { deleteall(); return -1; } } *path = (path_element_t *) malloc(sizeof(path_element_t) * (m_vecPath.size() + 1)); *path_count = m_vecPath.size(); for(i = 0; i < *path_count; i++) { (*path)[i].vertex_id = m_vecPath[i].vertex_id; (*path)[i].edge_id = m_vecPath[i].edge_id; (*path)[i].cost = m_vecPath[i].cost; } deleteall(); return 0; }