// -------------------------------------------------------------------------
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;
}
