// -------------------------------------------------------------------------
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;
}
void ListBaseTestCase::DeleteItems()
{
#ifndef __WXOSX__
wxListCtrl* const list = GetList();
EventCounter deleteitem(list, wxEVT_LIST_DELETE_ITEM);
EventCounter deleteall(list, wxEVT_LIST_DELETE_ALL_ITEMS);
list->InsertColumn(0, "Column 0", wxLIST_FORMAT_LEFT, 60);
list->InsertColumn(1, "Column 1", wxLIST_FORMAT_LEFT, 50);
list->InsertColumn(2, "Column 2", wxLIST_FORMAT_LEFT, 40);
list->InsertItem(0, "Item 0");
list->InsertItem(1, "Item 1");
list->InsertItem(2, "Item 1");
list->DeleteItem(0);
list->DeleteItem(0);
list->DeleteAllItems();
//Add some new items to tests ClearAll with
list->InsertColumn(0, "Column 0");
list->InsertItem(0, "Item 0");
list->InsertItem(1, "Item 1");
//Check that ClearAll actually sends a DELETE_ALL_ITEMS event
list->ClearAll();
//ClearAll and DeleteAllItems shouldn't send an event if there was nothing
//to clear
list->ClearAll();
list->DeleteAllItems();
CPPUNIT_ASSERT_EQUAL(2, deleteitem.GetCount());
CPPUNIT_ASSERT_EQUAL(2, deleteall.GetCount());
#endif
}
// -------------------------------------------------------------------------
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)
{
if(!m_bIsGraphConstructed)
{
init();
construct_graph(edges, edge_count, has_reverse_cost, directed);
m_bIsGraphConstructed = true;
}
std::priority_queue<PDP, std::vector<PDP>, std::greater<PDP> > que;
parent = new PARENT_PATH[edge_count + 1];
m_dCost = new CostHolder[edge_count + 1];
m_vecPath.clear();
unsigned int i;
for(i = 0; i <= edge_count; i++)
{
m_dCost[i].startCost = 1e15;
m_dCost[i].endCost = 1e15;
}
if(m_mapNodeId2Edge.find(start_vertex) == m_mapNodeId2Edge.end())
{
*err_msg = (char *)"Source Not Found";
deleteall();
return -1;
}
if(m_mapNodeId2Edge.find(end_vertex) == m_mapNodeId2Edge.end())
{
*err_msg = (char *)"Destination Not Found";
deleteall();
return -1;
}
LongVector vecsource = m_mapNodeId2Edge[start_vertex];
GraphEdgeInfo* cur_edge = NULL;
for(i = 0; i < vecsource.size(); i++)
{
cur_edge = m_vecEdgeVector[vecsource[i]];
if(cur_edge->m_lStartNode == start_vertex)
{
if(cur_edge->m_dCost >= 0.0)
{
m_dCost[cur_edge->m_lEdgeIndex].endCost= cur_edge->m_dCost;
parent[cur_edge->m_lEdgeIndex].v_pos[0] = -1;
parent[cur_edge->m_lEdgeIndex].ed_ind[0] = -1;
que.push(std::make_pair(cur_edge->m_dCost, std::make_pair(cur_edge->m_lEdgeIndex, true)));
}
}
else
{
if(cur_edge->m_dReverseCost >= 0.0)
{
m_dCost[cur_edge->m_lEdgeIndex].startCost = cur_edge->m_dReverseCost;
parent[cur_edge->m_lEdgeIndex].v_pos[1] = -1;
parent[cur_edge->m_lEdgeIndex].ed_ind[1] = -1;
que.push(std::make_pair(cur_edge->m_dReverseCost, std::make_pair(cur_edge->m_lEdgeIndex, false)));
}
}
}
//parent[start_vertex].v_id = -1;
//parent[start_vertex].ed_id = -1;
//m_dCost[start_vertex] = 0.0;
// int new_node;
int cur_node = -1;
while(!que.empty())
{
PDP cur_pos = que.top();
que.pop();
int cured_index = cur_pos.second.first;
cur_edge = m_vecEdgeVector[cured_index];
//GraphEdgeInfo* new_edge;
if(cur_pos.second.second) // explore edges connected to end node
{
cur_node = cur_edge->m_lEndNode;
if(cur_edge->m_dCost < 0.0)
continue;
if(cur_node == end_vertex)
break;
explore(cur_node, *cur_edge, true, cur_edge->m_vecEndConnedtedEdge, que);
}
else // explore edges connected to start node
{
cur_node = cur_edge->m_lStartNode;
if(cur_edge->m_dReverseCost < 0.0)
continue;
if(cur_node == end_vertex)
break;
explore(cur_node, *cur_edge, false, cur_edge->m_vecStartConnectedEdge, que);
}
}
if(cur_node != end_vertex)
{
if(m_lStartEdgeId == m_lEndEdgeId)
{
if(get_single_cost(1000.0, path, path_count))
{
return 0;
}
}
*err_msg = (char *)"Path Not Found";
deleteall();
return -1;
}
else
{
double total_cost;
if(cur_node == cur_edge->m_lStartNode)
{
total_cost = m_dCost[cur_edge->m_lEdgeIndex].startCost;
construct_path(cur_edge->m_lEdgeIndex, 1);
}
else
{
total_cost = m_dCost[cur_edge->m_lEdgeIndex].endCost;
construct_path(cur_edge->m_lEdgeIndex, 0);
}
path_element_t pelement;
pelement.vertex_id = end_vertex;
pelement.edge_id = -1;
pelement.cost = 0.0;
m_vecPath.push_back(pelement);
if(m_lStartEdgeId == m_lEndEdgeId)
{
if(get_single_cost(total_cost, path, path_count))
{
return 0;
}
}
*path = (path_element_t *) malloc(sizeof(path_element_t) * (m_vecPath.size() + 1));
*path_count = m_vecPath.size();
for(int 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;
}
if(isStartVirtual)
{
(*path)[0].vertex_id = -1;
(*path)[0].edge_id = m_lStartEdgeId;
}
if(isEndVirtual)
{
*path_count = *path_count - 1;
(*path)[*path_count - 1].edge_id = m_lEndEdgeId;
}
}
deleteall();
return 0;
}
// -------------------------------------------------------------------------
int GraphDefinition::my_dijkstra(int start_vertex, int end_vertex, unsigned int edge_count, char **err_msg)
{
if(!m_bIsGraphConstructed)
{
*err_msg = (char *)"Graph not Ready!";
return -1;
}
unsigned int i;
for(i = 0; i <= edge_count; i++)
{
m_dCost[i].startCost = 1e15;
m_dCost[i].endCost = 1e15;
}
if(m_mapNodeId2Edge.find(start_vertex) == m_mapNodeId2Edge.end())
{
*err_msg = (char *)"Source Not Found";
deleteall();
return -1;
}
if(m_mapNodeId2Edge.find(end_vertex) == m_mapNodeId2Edge.end())
{
*err_msg = (char *)"Destination Not Found";
deleteall();
return -1;
}
std::priority_queue<PDP, std::vector<PDP>, std::greater<PDP> > que;
LongVector vecsource = m_mapNodeId2Edge[start_vertex];
GraphEdgeInfo* cur_edge = NULL;
for(i = 0; i < vecsource.size(); i++)
{
cur_edge = m_vecEdgeVector[vecsource[i]];
if(cur_edge->m_lStartNode == start_vertex)
{
if(cur_edge->m_dCost >= 0.0)
{
m_dCost[cur_edge->m_lEdgeIndex].endCost= cur_edge->m_dCost;
parent[cur_edge->m_lEdgeIndex].v_pos[0] = -1;
parent[cur_edge->m_lEdgeIndex].ed_ind[0] = -1;
que.push(std::make_pair(cur_edge->m_dCost, std::make_pair(cur_edge->m_lEdgeIndex, true)));
}
}
else
{
if(cur_edge->m_dReverseCost >= 0.0)
{
m_dCost[cur_edge->m_lEdgeIndex].startCost = cur_edge->m_dReverseCost;
parent[cur_edge->m_lEdgeIndex].v_pos[1] = -1;
parent[cur_edge->m_lEdgeIndex].ed_ind[1] = -1;
que.push(std::make_pair(cur_edge->m_dReverseCost, std::make_pair(cur_edge->m_lEdgeIndex, false)));
}
}
}
// int new_node;
int cur_node = -1;
while(!que.empty())
{
PDP cur_pos = que.top();
que.pop();
int cured_index = cur_pos.second.first;
cur_edge = m_vecEdgeVector[cured_index];
//GraphEdgeInfo* new_edge;
if(cur_pos.second.second) // explore edges connected to end node
{
cur_node = cur_edge->m_lEndNode;
if(cur_edge->m_dCost < 0.0)
continue;
if(cur_node == end_vertex)
break;
explore(cur_node, *cur_edge, true, cur_edge->m_vecEndConnedtedEdge, que);
}
else // explore edges connected to start node
{
cur_node = cur_edge->m_lStartNode;
if(cur_edge->m_dReverseCost < 0.0)
continue;
if(cur_node == end_vertex)
break;
explore(cur_node, *cur_edge, false, cur_edge->m_vecStartConnectedEdge, que);
}
}
if(cur_node != end_vertex)
{
*err_msg = (char *)"Path Not Found";
deleteall();
return -1;
}
else
{
// double total_cost; //set but not used
if(cur_node == cur_edge->m_lStartNode)
{
// total_cost = m_dCost[cur_edge->m_lEdgeIndex].startCost;
construct_path(cur_edge->m_lEdgeIndex, 1);
}
else
{
// total_cost = m_dCost[cur_edge->m_lEdgeIndex].endCost;
construct_path(cur_edge->m_lEdgeIndex, 0);
}
path_element_t pelement;
pelement.vertex_id = end_vertex;
pelement.edge_id = -1;
pelement.cost = 0.0;
m_vecPath.push_back(pelement);
}
return 0;
}
// -------------------------------------------------------------------------
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;
}
TVector::~TVector(){
deleteall();
}
int BiDirAStar:: bidir_astar(edge_astar_t *edges, size_t edge_count, int maxNode, int start_vertex, int end_vertex,
path_element_t **path, size_t *path_count, char **err_msg)
{
max_node_id = maxNode;
max_edge_id = -1;
// Allocate memory for local storage like cost and parent holder
initall(maxNode);
// construct the graph from the edge list, i.e. populate node and edge data structures
construct_graph(edges, edge_count, maxNode);
m_lStartNodeId = start_vertex;
m_lEndNodeId = end_vertex;
// int nodeCount = m_vecNodeVector.size();
MinHeap fque(maxNode + 2);
MinHeap rque(maxNode + 2);
//std::priority_queue<PDI, std::vector<PDI>, std::greater<PDI> > fque;
//std::priority_queue<PDI, std::vector<PDI>, std::greater<PDI> > rque;
m_vecPath.clear();
// Initialize the forward search
m_pFParent[start_vertex].par_Node = -1;
m_pFParent[start_vertex].par_Edge = -1;
m_pFCost[start_vertex] = 0.0;
fque.push(std::make_pair(0.0, start_vertex));
// Initialize the reverse search
m_pRParent[end_vertex].par_Node = -1;
m_pRParent[end_vertex].par_Edge = -1;
m_pRCost[end_vertex] = 0.0;
rque.push(std::make_pair(0.0, end_vertex));
// int new_node;
int cur_node;
// int dir;
/*
The main loop. The algorithm is as follows:
1. IF the sum of the current minimum of both heap is greater than so far found path, we cannot get any better, so break the loop.
2. IF the reverse heap minimum is lower than the forward heap minimum, explore from reverse direction.
3. ELSE explore from the forward directtion.
*/
while(!fque.empty() && !rque.empty())
{
PDI fTop = fque.top();
PDI rTop = rque.top();
if(m_pFCost[fTop.second] + m_pRCost[rTop.second] > m_MinCost) //We are done, there is no path with lower cost
break;
if(rTop.first < fTop.first) // Explore from reverse queue
{
if(rTop.first > m_MinCost)
break;
cur_node = rTop.second;
int dir = -1;
rque.pop();
explore(cur_node, m_pRCost[rTop.second], dir, rque);
}
else // Explore from forward queue
{
if(fTop.first > m_MinCost)
break;
cur_node = fTop.second;
int dir = 1;
fque.pop();
explore(cur_node, m_pFCost[fTop.second], dir, fque);
}
}
/*
Path reconstruction part. m_MidNode is the joining point where two searches meet to make a shortest path. It is updated in explore.
If it contains -1, then no path is found. Other wise we have a shortest path and that is reconstructed in the m_vecPath.
*/
if(m_MidNode == -1)
{
*err_msg = (char *)"Path Not Found";
deleteall();
return -1;
}
else
{
// reconstruct path from forward search
fconstruct_path(m_MidNode);
// reconstruct path from backward search
rconstruct_path(m_MidNode);
// insert the last row in the path trace (having edge_id = -1 and cost = 0.0)
path_element_t pelement;
pelement.vertex_id = end_vertex;
pelement.edge_id = -1;
pelement.cost = 0.0;
m_vecPath.push_back(pelement);
// Transfer data path to path_element_t format and allocate memory and populate the pointer
*path = (path_element_t *) malloc(sizeof(path_element_t) * (m_vecPath.size() + 1));
*path_count = 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 BiDirDijkstra:: bidir_dijkstra(edge_t *edges, unsigned int edge_count, int maxNode, int start_vertex, int end_vertex,
path_element_t **path, int *path_count, char **err_msg)
{
max_node_id = maxNode;
max_edge_id = -1;
init();
construct_graph(edges, edge_count, maxNode);
int nodeCount = m_vecNodeVector.size();
std::priority_queue<PDI, std::vector<PDI>, std::greater<PDI> > fque;
std::priority_queue<PDI, std::vector<PDI>, std::greater<PDI> > rque;
m_vecPath.clear();
int i;
initall(maxNode);
m_pFParent[start_vertex].par_Node = -1;
m_pFParent[start_vertex].par_Edge = -1;
m_pFCost[start_vertex] = 0.0;
fque.push(std::make_pair(0.0, start_vertex));
m_pRParent[end_vertex].par_Node = -1;
m_pRParent[end_vertex].par_Edge = -1;
m_pRCost[end_vertex] = 0.0;
rque.push(std::make_pair(0.0, end_vertex));
int new_node;
int cur_node;
int dir;
while(!fque.empty() && !rque.empty())
{
PDI fTop = fque.top();
PDI rTop = rque.top();
if(fTop.first + rTop.first > m_MinCost) //We are done, there is no path with lower cost
break;
if(rTop.first < fTop.first) // Explore from reverse queue
{
cur_node = rTop.second;
int dir = -1;
rque.pop();
explore(cur_node, rTop.first, dir, rque);
}
else // Explore from forward queue
{
cur_node = fTop.second;
int dir = 1;
fque.pop();
explore(cur_node, fTop.first, dir, fque);
}
}
if(m_MidNode == -1)
{
*err_msg = (char *)"Path Not Found";
deleteall();
return -1;
}
else
{
fconstruct_path(m_MidNode);
rconstruct_path(m_MidNode);
path_element_t pelement;
pelement.vertex_id = end_vertex;
pelement.edge_id = -1;
pelement.cost = 0.0;
m_vecPath.push_back(pelement);
*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;
}
