// -------------------------------------------------------------------------
void GraphDefinition::explore(
int cur_node,
GraphEdgeInfo& cur_edge,
bool isStart,
LongVector &vecIndex,
std::priority_queue<PDP, std::vector<PDP>,
std::greater<PDP> > &que)
{
unsigned int i;
double extCost = 0.0;
GraphEdgeInfo* new_edge;
// int new_node;
double totalCost;
for(i = 0; i < vecIndex.size(); i++)
{
new_edge = m_vecEdgeVector[vecIndex[i]];
extCost = 0.0;
if(m_bIsturnRestrictOn)
{
extCost = getRestrictionCost(cur_edge.m_lEdgeIndex, *new_edge, isStart);
}
if(new_edge->m_lStartNode == cur_node)
{
if(new_edge->m_dCost >= 0.0)
{
//new_node = new_edge->m_lEndNode;
if(isStart)
totalCost = m_dCost[cur_edge.m_lEdgeIndex].endCost + new_edge->m_dCost + extCost;
else
totalCost = m_dCost[cur_edge.m_lEdgeIndex].startCost + new_edge->m_dCost + extCost;
if(totalCost < m_dCost[vecIndex[i]].endCost)
{
m_dCost[vecIndex[i]].endCost = totalCost;
parent[new_edge->m_lEdgeIndex].v_pos[0] = (isStart?0:1);
parent[new_edge->m_lEdgeIndex].ed_ind[0] = cur_edge.m_lEdgeIndex;
que.push(std::make_pair(totalCost, std::make_pair(new_edge->m_lEdgeIndex, true)));
}
}
}
else
{
if(new_edge->m_dReverseCost >= 0.0)
{
// new_node = new_edge->m_lStartNode;
if(isStart)
totalCost = m_dCost[cur_edge.m_lEdgeIndex].endCost + new_edge->m_dReverseCost + extCost;
else
totalCost = m_dCost[cur_edge.m_lEdgeIndex].startCost + new_edge->m_dReverseCost + extCost;
if(totalCost < m_dCost[vecIndex[i]].startCost)
{
m_dCost[vecIndex[i]].startCost = totalCost;
parent[new_edge->m_lEdgeIndex].v_pos[1] = (isStart?0:1);
parent[new_edge->m_lEdgeIndex].ed_ind[1] = cur_edge.m_lEdgeIndex;
que.push(std::make_pair(totalCost, std::make_pair(new_edge->m_lEdgeIndex, false)));
}
}
}
}
}
// -------------------------------------------------------------------------
void Pgr_trspHandler::explore(
int64_t cur_node,
const EdgeInfo cur_edge,
bool isStart) {
double extra_cost = 0.0;
double totalCost;
auto vecIndex = cur_edge.get_idx(isStart);
for (const auto &index : vecIndex) {
auto edge = m_edges[index];
extra_cost = getRestrictionCost(
cur_edge.idx(),
edge, isStart);
if ((edge.startNode() == cur_node) && (edge.cost() >= 0.0)) {
totalCost = get_tot_cost(
edge.cost() + extra_cost,
cur_edge.idx(),
isStart);
if (totalCost < m_dCost[index].endCost) {
m_dCost[index].endCost = totalCost;
m_parent[edge.idx()].v_pos[RC_EDGE] = (isStart? C_EDGE : RC_EDGE);
m_parent[edge.idx()].e_idx[RC_EDGE] =
cur_edge.idx();
add_to_que(totalCost, edge.idx(), true);
}
}
if ((edge.endNode() == cur_node) && (edge.r_cost() >= 0.0)) {
totalCost = get_tot_cost(
edge.r_cost() + extra_cost,
cur_edge.idx(),
isStart);
if (totalCost < m_dCost[index].startCost) {
m_dCost[index].startCost = totalCost;
m_parent[edge.idx()].v_pos[C_EDGE] = (isStart? C_EDGE : RC_EDGE);
m_parent[edge.idx()].e_idx[C_EDGE] = cur_edge.idx();
add_to_que(totalCost, edge.idx(), false);
}
}
} // for
}