pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

routing fixes and style improvements

Browse source
This commit is contained in:
Lev Dragunov 2015-01-30 17:23:05 +03:00 • committed by Alex Zolotarev
parent 455f22d514
commit 32c63bea62
5 changed files with 98 additions and 183 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

93
generator/routing_generator.cpp
View file

@ -28,26 +28,11 @@
#include "../routing/osrm_router.hpp"
#include "../routing/cross_routing_context.hpp"
#define BORDERS_DIR "borders/"
#define BORDERS_EXTENSION ".borders"
namespace routing
{
//Int bacause shortest_path_length has same type =(
/*int CalculateCrossLength(size_t start, size_t stop, RawDataFacadeT & facade)
{
FeatureGraphNodeVecT taskNode(2), ftaskNode(2);
OsrmRouter::GenerateRoutingTaskFromNodeId(start, taskNode);
OsrmRouter::GenerateRoutingTaskFromNodeId(stop, ftaskNode);
RawRoutingResultT routingResult;
if (OsrmRouter::FindSingleRoute(taskNode, ftaskNode, facade, routingResult))
{
return routingResult.m_routePath.shortest_path_length;
}
return std::numeric_limits<int>::max();
}*/
//Routines to get borders from tree
class GetCountriesBordersByName
{
@ -103,16 +88,10 @@ public:
CheckPointInBorder getter(m_point, inside);
c.m_regions.ForEachInRect(m2::RectD(m_point, m_point), getter);
if (inside)
{
m_name = c.m_name;
LOG(LINFO, ("FROM INSIDE 0_0 ", m_name));
}
else
LOG(LINFO, ("NOT INSIDE ", c.m_name));
}
};
static double const EQUAL_POINT_RADIUS_M = 2.0;
void BuildRoutingIndex(string const & baseDir, string const & countryName, string const & osrmFile)
@ -143,23 +122,9 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
m2::RegionD finalBorder;
finalBorder.Data().reserve(border.Data().size());
for (auto p = tmpRegionBorders.data()->Begin(); p<tmpRegionBorders.data()->End(); ++p)
finalBorder.AddPoint(m2::PointD(MercatorBounds::XToLon(p->x), MercatorBounds::YToLat(p->y)));
finalBorder.AddPoint({MercatorBounds::XToLon(p->x), MercatorBounds::YToLat(p->y)});
regionBorders.push_back(finalBorder);
}
/*
vector<m2::RegionD> tmpRegionBorders;
if (osm::LoadBorders(baseDir + BORDERS_DIR + countryName + BORDERS_EXTENSION, tmpRegionBorders))
{
LOG(LINFO, ("Found",tmpRegionBorders.size(),"region borders"));
for (m2::RegionD const& border: tmpRegionBorders)
{
m2::RegionD finalBorder;
finalBorder.Data().reserve(border.Data().size());
for (auto p = tmpRegionBorders.data()->Begin(); p<tmpRegionBorders.data()->End(); ++p)
finalBorder.AddPoint(m2::PointD(MercatorBounds::XToLon(p->x), MercatorBounds::YToLat(p->y)));
regionBorders.push_back(finalBorder);
}
}*/
}
gen::OsmID2FeatureID osm2ft;
@ -197,10 +162,6 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
// check nearest to goverment borders
for (m2::RegionD const& border: regionBorders)
{
//if ( (border.Contains(pts[0]) ^ border.Contains(pts[1]))) // || border.atBorder(pts[0], 0.005) || border.atBorder(pts[1], 0.005))
//{
// outgoingNodes.push_back(nodeId);
//}
bool outStart = border.Contains(pts[0]), outEnd = border.Contains(pts[1]);
if (outStart == true && outEnd == false)
{
@ -210,8 +171,9 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
m_countries.ForEachInRect(m2::RectD(mercatorPoint, mercatorPoint), getter);
crossContext.addOutgoingNode(nodeId, mwmName);
}
if (outStart == false && outEnd == true)
crossContext.addIngoingNode(nodeId);
else
if (outStart == false && outEnd == true)
crossContext.addIngoingNode(nodeId);
}
}
}
@ -381,22 +343,6 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
matrixSource.Read(&matrixBuffer[0], matrixSource.Size());
facade.LoadRawData(edgeBuffer.data(), edgeIdsBuffer.data(), shortcutsBuffer.data(), matrixBuffer.data());
map<size_t, size_t> incomeEdgeCountMap;
size_t const nodeDataSize = nodeData.size();
for (size_t nodeId = 0; nodeId < nodeDataSize; ++nodeId)
{
for(auto e: facade.GetAdjacentEdgeRange(nodeId))
{
const size_t target_node = facade.GetTarget(e);
auto const it = incomeEdgeCountMap.find(target_node);
if (it==incomeEdgeCountMap.end())
incomeEdgeCountMap.insert(make_pair(target_node, 1));
else
incomeEdgeCountMap[target_node] += 1;
}
}
LOG(LINFO, ("Calculating weight map between outgoing nodes"));
crossContext.reserveAdjacencyMatrix();
auto in = crossContext.GetIngoingIterators();
@ -418,10 +364,8 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
for (auto j=out.first; j<out.second; ++j )
{
crossContext.setAdjacencyCost(i, j, *res);
LOG(LINFO, ("Have weight", *res));
++res;
}
LOG(LINFO, ("Calculating weight map between outgoing nodes DONE"));
}
@ -436,31 +380,4 @@ void BuildRoutingIndex(string const & baseDir, string const & countryName, strin
VERIFY(my::GetFileSize(fPath, sz), ());
LOG(LINFO, ("Nodes stored:", stored, "Routing index file size:", sz));
}
void BuildCrossesRoutingIndex(string const & baseDir)
{
/*
vector<size_t> outgoingNodes1;
vector<size_t> outgoingNodes2;
vector<size_t> result;
const string file1_path = baseDir+"Russia_central.mwm.routing";
const string file2_path = baseDir+"Belarus.mwm.routing";
FilesMappingContainer f1Cont(file1_path);
FilesMappingContainer f2Cont(file2_path);
ReaderSource<FileReader> r1(f1Cont.GetReader(ROUTING_OUTGOING_FILE_TAG));
ReaderSource<FileReader> r2(f2Cont.GetReader(ROUTING_OUTGOING_FILE_TAG));
LOG(LINFO, ("Loading mwms"));
rw::ReadVectorOfPOD(r1,outgoingNodes1);
rw::ReadVectorOfPOD(r2,outgoingNodes2);
LOG(LINFO, ("Have outgoing lengthes", outgoingNodes1.size(), outgoingNodes2.size()));
sort(outgoingNodes1.begin(), outgoingNodes1.end());
sort(outgoingNodes2.begin(), outgoingNodes2.end());
set_intersection(outgoingNodes1.begin(),outgoingNodes1.end(),outgoingNodes2.begin(),outgoingNodes2.end(),back_inserter(result));
LOG(LINFO, ("Have nodes after intersection", result.size()));
*/
}
}

5
generator/routing_generator.hpp
View file

@ -11,11 +11,6 @@ namespace routing
/*!
* \brief The OutgoungNodeT struct. Contains node identifier and it's coordinate to calculate same nodes at different mwm's
*/
/*struct OutgoungNodeT {
size_t node_id;
double x;
double y;
};*/
typedef size_t OutgoingNodeT;
typedef std::vector<OutgoingNodeT> OutgoingVectorT;

4
routing/cross_routing_context.hpp
View file

@ -46,6 +46,8 @@ public:
void Load(Reader const & r)
{
if (m_adjacencyMatrix.size())
return; //Already loaded
size_t size, pos=0;
r.Read(pos, &size, sizeof(size_t));
pos += sizeof(size_t);
@ -82,7 +84,7 @@ public:
//Writing part
void Save(Writer & w)
{
//LOG(LINFO, ("Have ingoing", m_ingoingNodes.size(), "outgoing", m_outgoingNodes.size, "neighbors", m_neighborMwmList.size()));
sort(m_ingoingNodes.begin(), m_ingoingNodes.end());
size_t size = m_ingoingNodes.size();
w.Write(&size, sizeof(size_t));
w.Write(&(m_ingoingNodes[0]), sizeof(size_t) * size);

152
routing/osrm_router.cpp
View file

@ -499,26 +499,28 @@ bool IsRouteExist(RawRouteData const & r)
}
FeatureGraphNode const & OsrmRouter::FilterWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
MultiroutingTaskPointT::const_iterator OsrmRouter::FilterWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
std::vector<EdgeWeight> &weightMatrix, bool const filterSource)
{
if (filterSource)
{
for (size_t i=0; i<sources.size(); ++i)
for (size_t j=0; j<targets.size(); ++j)
if (weightMatrix[ i*sources.size() + j] < numeric_limits<EdgeWeight>::max())
if (weightMatrix[ i*sources.size() + j] < INVALID_EDGE_WEIGHT)
{
weightMatrix.erase(weightMatrix.begin(), weightMatrix.begin()+i*targets.size());
weightMatrix.erase(weightMatrix.begin()+targets.size(), weightMatrix.end());
ASSERT(weightMatrix.size()==targets.size(), ());
return sources[i];
return sources.cbegin()+i;
}
return sources.cend();
}
else
{
for (size_t i=0; i<targets.size(); ++i)
for (size_t j=0; j<sources.size(); ++j)
if (weightMatrix[ j*sources.size() + i] < numeric_limits<EdgeWeight>::max())
if (weightMatrix[ j*sources.size() + i] < INVALID_EDGE_WEIGHT)
{
for (int k=sources.size()-1; k>-1; --k)
{
@ -526,10 +528,10 @@ FeatureGraphNode const & OsrmRouter::FilterWeightsMatrix(MultiroutingTaskPointT
weightMatrix.erase(weightMatrix.begin()+k*targets.size()+i+1, weightMatrix.begin()+(k+1)*targets.size());
}
ASSERT(weightMatrix.size()==sources.size(), ());
return targets[i];
return targets.cbegin() + i;
}
return targets.cend();
}
return FeatureGraphNode();
}
void OsrmRouter::FindWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
@ -642,41 +644,28 @@ void OsrmRouter::GenerateRoutingTaskFromNodeId(const size_t nodeId, FeatureGraph
taskNode.m_node.reverse_offset = 0;
taskNode.m_node.name_id = 1;
taskNode.m_seg.m_fid = OsrmFtSegMapping::FtSeg::INVALID_FID;
/*
taskNode.resize(2);
taskNode[0].m_node.forward_node_id = nodeId;
taskNode[0].m_node.reverse_node_id = INVALID_NODE_ID;
taskNode[0].m_node.forward_weight = 0;
taskNode[0].m_node.reverse_weight = 0;
taskNode[0].m_seg.m_fid = OsrmFtSegMapping::FtSeg::INVALID_FID;
taskNode[1].m_node.forward_node_id = INVALID_NODE_ID;
taskNode[1].m_node.reverse_node_id = nodeId;
taskNode[1].m_node.forward_weight = 0;
taskNode[1].m_node.reverse_weight = 0;
taskNode[1].m_seg.m_fid = OsrmFtSegMapping::FtSeg::INVALID_FID;
*/
}
size_t OsrmRouter::FindNextMwmNode(RoutingMappingPtrT const & startMapping, size_t startId, RoutingMappingPtrT const & targetMapping)
{
m2::PointD startPoint = GetPointByNodeId(startId, startMapping, false);
m2::PointD startPointTmp = GetPointByNodeId(startId, startMapping, true);
startPoint = m2::PointD(MercatorBounds::XToLon(startPoint.x), MercatorBounds::YToLat(startPoint.y));
startPointTmp = m2::PointD(MercatorBounds::XToLon(startPointTmp.x), MercatorBounds::YToLat(startPointTmp.y));
m2::PointD startPointStart = GetPointByNodeId(startId, startMapping, true);
m2::PointD startPointEnd = GetPointByNodeId(startId, startMapping, false);
startPointStart = {MercatorBounds::XToLon(startPointStart.x), MercatorBounds::YToLat(startPointStart.y)};
startPointEnd = {MercatorBounds::XToLon(startPointEnd.x), MercatorBounds::YToLat(startPointEnd.y)};
CrossRoutingContext const & targetContext = targetMapping->dataFacade.getRoutingContext();
auto income_iters = targetContext.GetIngoingIterators();
for (auto i=income_iters.first; i<income_iters.second; ++i)
{
m2::PointD targetPoint = GetPointByNodeId(*i, targetMapping, true);
m2::PointD targetPointTmp = GetPointByNodeId(*i, targetMapping, false);
m2::PointD targetPointEnd = GetPointByNodeId(*i, targetMapping, false);
targetPoint = m2::PointD(MercatorBounds::XToLon(targetPoint.x), MercatorBounds::YToLat(targetPoint.y));
targetPointTmp = m2::PointD(MercatorBounds::XToLon(targetPointTmp.x), MercatorBounds::YToLat(targetPointTmp.y));
targetPointEnd = m2::PointD(MercatorBounds::XToLon(targetPointEnd.x), MercatorBounds::YToLat(targetPointEnd.y));
double const dist = min(min(ms::DistanceOnEarth((startPoint.y), (startPoint.x), (targetPoint.y), (targetPoint.x)),
ms::DistanceOnEarth((startPointTmp.y), (startPointTmp.x), (targetPoint.y), (targetPoint.x))),
min(ms::DistanceOnEarth((startPoint.y), (startPoint.x), (targetPointTmp.y), (targetPointTmp.x)),
ms::DistanceOnEarth((startPointTmp.y), (startPointTmp.x), (targetPointTmp.y), (targetPointTmp.x))));
if (dist<10)
double const dist = min(min(ms::DistanceOnEarth(startPointEnd.y, startPointEnd.x, targetPoint.y, targetPoint.x),
ms::DistanceOnEarth(startPointStart.y, startPointStart.x, targetPoint.y, targetPoint.x)),
min(ms::DistanceOnEarth(startPointEnd.y, startPointEnd.x, targetPointEnd.y, targetPointEnd.x),
ms::DistanceOnEarth(startPointStart.y, startPointStart.x, targetPointEnd.y, targetPointEnd.x)));
if (dist < FEATURE_BY_POINT_RADIUS_M)
return *i;
}
return INVALID_NODE_ID;
@ -710,7 +699,6 @@ OsrmRouter::ResultCode OsrmRouter::MakeRouteFromCrossesPath(CheckedPathT const &
RoutingMappingPtrT mwmMapping;
mwmMapping = m_indexManager.GetMappingByName(cross.mwmName, m_pIndex);
mwmMapping->LoadFacade();
LOG(LINFO, ("mwmFacade data", mwmMapping->dataFacade.GetNumberOfNodes()));
if (!FindSingleRoute(startTask, targetTask, mwmMapping->dataFacade, routingResult))
{
mwmMapping->FreeFacade();
@ -744,6 +732,8 @@ OsrmRouter::ResultCode OsrmRouter::MakeRouteFromCrossesPath(CheckedPathT const &
Points.pop_back(); //You at the end point
Points.insert(Points.end(), ++mwmPoints.begin(), mwmPoints.end());
TurnsGeom.insert(TurnsGeom.end(), mwmTurnsGeom.begin(), mwmTurnsGeom.end());
mwmMapping->FreeFacade();
mwmMapping->Unmap();
}
route.SetGeometry(Points.begin(), Points.end());
@ -767,25 +757,26 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
return e;
}
MappingGuard startMappingGuard(startMapping);
MappingGuard finalMappingGuard(finalMapping);
UNUSED_VALUE(startMappingGuard);
UNUSED_VALUE(finalMappingGuard);
// 3. Find start/end nodes.
FeatureGraphNodeVecT startTask;
{
startMapping->Map();
ResultCode const code = FindPhantomNodes(startMapping->GetName(), startPt, startDr, startTask, MAX_NODE_CANDIDATES, startMapping);
if (code != NoError)
return code;
startMapping->Unmap();
}
{
if (finalPt != m_CachedTargetPoint)
{
finalMapping->Map();
ResultCode const code = FindPhantomNodes(finalMapping->GetName(), finalPt, m2::PointD::Zero(), m_CachedTargetTask, MAX_NODE_CANDIDATES, finalMapping);
if (code != NoError)
return code;
m_CachedTargetPoint = finalPt;
finalMapping->Unmap();
}
}
if (m_requestCancel)
@ -797,20 +788,16 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
if (startMapping->GetName() == finalMapping->GetName())
{
LOG(LINFO, ("Single mwm routing case"));
startMapping->LoadFacade();
if (!FindSingleRoute(startTask, m_CachedTargetTask, startMapping->dataFacade, routingResult))
{
startMapping->FreeFacade();
return RouteNotFound;
}
if (m_requestCancel)
{
startMapping->FreeFacade();
return Cancelled;
}
// 5. Restore route.
startMapping->Map();
Route::TurnsT turnsDir;
Route::TimesT times;
@ -824,19 +811,11 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
route.SetSectionTimes(times);
route.SetTurnInstructionsGeometry(turnsGeom);
startMapping->FreeFacade();
startMapping->Unmap();
return NoError;
}
else
{
LOG(LINFO, ("Different mwm routing case"));
//NodeIdVectorT startBorderNodes;
//NodeIdVectorT finalBorderNodes;
startMapping->Map();
finalMapping->Map();
startMapping->LoadFacade();
finalMapping->LoadFacade();
CrossRoutingContext const & startContext = startMapping->dataFacade.getRoutingContext();
auto out_iterators = startContext.GetOutgoingIterators();
@ -857,15 +836,15 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
FindWeightsMatrix(sources, targets, startMapping->dataFacade, weights);
FindWeightsMatrix(income_sources, income_targets, finalMapping->dataFacade, target_weights);
FeatureGraphNode const & sourceNode = FilterWeightsMatrix(sources, targets,weights, true);
FeatureGraphNode const & targetNode = FilterWeightsMatrix(income_sources, income_targets, target_weights, false);
auto sourceNodeIter = FilterWeightsMatrix(sources, targets,weights, true);
auto targetNodeIter = FilterWeightsMatrix(income_sources, income_targets, target_weights, false);
if (!sourceNode.m_seg.IsValid())
if (sourceNodeIter == sources.cend())
return StartPointNotFound;
if (!targetNode.m_seg.IsValid())
if (targetNodeIter == targets.cend())
return EndPointNotFound;
EdgeWeight finalWeight = numeric_limits<EdgeWeight>::max();
EdgeWeight finalWeight = INVALID_EDGE_WEIGHT;
CheckedPathT finalPath;
struct pathChecker{
@ -879,7 +858,7 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
for (size_t j=0; j<targets.size(); ++j)
{
if (weights[j] < numeric_limits<EdgeWeight>::max())
if (weights[j] < INVALID_EDGE_WEIGHT)
{
string const & nextMwm = startContext.getOutgoingMwmName((out_iterators.first+j)->second);
RoutingMappingPtrT nextMapping;
@ -891,7 +870,8 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
{
continue; //There is no outgoing mwm
}
MappingGuard nextMappingGuard(nextMapping);
UNUSED_VALUE(nextMappingGuard);
size_t tNodeId = (out_iterators.first+j)->first;
size_t nextNodeId = FindNextMwmNode(startMapping, tNodeId, nextMapping);
if(nextNodeId == INVALID_NODE_ID)
@ -902,7 +882,7 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
CheckedPathT tmpPath;
FeatureGraphNode tmpNode;
OsrmRouter::GenerateRoutingTaskFromNodeId(nextNodeId, tmpNode);
tmpPath.push_back({startMapping->GetName(), sourceNode, targets[j], weights[j]});
tmpPath.push_back({startMapping->GetName(), *sourceNodeIter, targets[j], weights[j]});
tmpPath.push_back({nextMapping->GetName(), tmpNode, tmpNode, 0});
crossTasks.push(tmpPath);
}
@ -912,15 +892,15 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
ASSERT(it != income_iterators.second, ());
const size_t targetNumber = distance(income_iterators.first, it);
const EdgeWeight targetWeight = target_weights[targetNumber];
if (targetWeight == numeric_limits<EdgeWeight>::max())
if (targetWeight == INVALID_EDGE_WEIGHT)
continue;
const EdgeWeight newWeight = weights[j] + targetWeight;
if (newWeight<finalWeight)
{
finalWeight = newWeight;
finalPath.clear();
finalPath.push_back({startMapping->GetName(), sourceNode, targets[j], weights[j]});
finalPath.push_back({finalMapping->GetName(), income_sources[targetNumber], targetNode, targetWeight});
finalPath.push_back({startMapping->GetName(), *sourceNodeIter, targets[j], weights[j]});
finalPath.push_back({finalMapping->GetName(), income_sources[targetNumber], *targetNodeIter, targetWeight});
}
}
}
@ -930,8 +910,9 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
{
while (getPathWeight(crossTasks.top())<finalWeight)
{
CheckedPathT const & topTask = crossTasks.top();
RoutePathCross const & cross = topTask.back();
CheckedPathT const topTask = crossTasks.top();
crossTasks.pop();
RoutePathCross const cross = topTask.back();
RoutingMappingPtrT currentMapping;
try
{
@ -939,31 +920,23 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
}
catch (OsrmRouter::ResultCode e)
{
crossTasks.pop();
continue; //There is no outgoing mwm
}
currentMapping->LoadFacade();
currentMapping->Map();
MappingGuard currentMappingGuard(currentMapping);
UNUSED_VALUE(currentMappingGuard);
CrossRoutingContext const & currentContext = currentMapping->dataFacade.getRoutingContext();
auto current_in_iterators = currentContext.GetIngoingIterators();
auto current_out_iterators = currentContext.GetOutgoingIterators();
//find income number
//auto const iit = find(current_in_iterators.first, current_in_iterators.second, cross.startNode.m_node.forward_node_id);
auto iit = current_in_iterators.second;
for (auto q = current_in_iterators.first; q<current_in_iterators.second; ++q)
if (*q==cross.startNode.m_node.forward_node_id)
{
iit = q;
break;
}
auto const iit = find(current_in_iterators.first, current_in_iterators.second, cross.startNode.m_node.forward_node_id);
ASSERT(iit != current_in_iterators.second, ());
//find outs
for (auto oit=current_out_iterators.first; oit!= current_out_iterators.second; ++oit)
{
const EdgeWeight outWeight = currentContext.getAdjacencyCost(iit, oit);
if (outWeight != numeric_limits<EdgeWeight>::max())
if (outWeight != INVALID_EDGE_WEIGHT)
{
if (getPathWeight(topTask)+outWeight < finalWeight)
{
@ -978,10 +951,10 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
continue; //There is no outgoing mwm
}
nextMapping->Map();
nextMapping->LoadFacade();
size_t tNodeId = oit->first;
auto const outNode = make_pair(tNodeId, startMapping->GetName());
MappingGuard nextMappingGuard(nextMapping);
UNUSED_VALUE(nextMappingGuard);
size_t const tNodeId = oit->first;
auto const outNode = make_pair(tNodeId, currentMapping->GetName());
if (checkedOuts.find(outNode)!=checkedOuts.end())
continue;
checkedOuts.insert(outNode);
@ -990,12 +963,12 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
continue;
if (nextMwm != finalMapping->GetName())
{
CheckedPathT tmpPath(crossTasks.top());
crossTasks.pop();
CheckedPathT tmpPath(topTask);
FeatureGraphNode startNode, stopNode, tmpNode;
OsrmRouter::GenerateRoutingTaskFromNodeId(nextNodeId, tmpNode);
OsrmRouter::GenerateRoutingTaskFromNodeId(*iit, startNode);
OsrmRouter::GenerateRoutingTaskFromNodeId(oit->first, stopNode);
OsrmRouter::GenerateRoutingTaskFromNodeId(tNodeId, stopNode);
tmpPath.pop_back();
tmpPath.push_back({currentMapping->GetName(), startNode, stopNode, outWeight});
tmpPath.push_back({nextMapping->GetName(), tmpNode, tmpNode, 0});
crossTasks.push(tmpPath);
@ -1006,32 +979,30 @@ OsrmRouter::ResultCode OsrmRouter::CalculateRouteImpl(m2::PointD const & startPt
ASSERT(it != income_iterators.second, ());
const size_t targetNumber = distance(income_iterators.first, it);
const EdgeWeight targetWeight = target_weights[targetNumber];
if (targetWeight == numeric_limits<EdgeWeight>::max())
if (targetWeight == INVALID_EDGE_WEIGHT)
continue;
const EdgeWeight newWeight = getPathWeight(topTask) + outWeight + targetWeight;
if (newWeight<finalWeight)
{
finalWeight = newWeight;
finalPath = CheckedPathT(crossTasks.top());
finalPath = CheckedPathT(topTask);
finalPath.pop_back();
FeatureGraphNode startNode, stopNode;
OsrmRouter::GenerateRoutingTaskFromNodeId(*iit, startNode);
OsrmRouter::GenerateRoutingTaskFromNodeId(oit->first, stopNode);
OsrmRouter::GenerateRoutingTaskFromNodeId(tNodeId, stopNode);
finalPath.push_back({currentMapping->GetName(), startNode, stopNode, outWeight});
finalPath.push_back({finalMapping->GetName(), income_sources[targetNumber], targetNode, targetWeight});
finalPath.push_back({nextMwm, income_sources[targetNumber], *targetNodeIter, targetWeight});
}
}
}
}
}
crossTasks.pop();
if (!crossTasks.size())
break;
}
}
LOG(LINFO, ("Facade data", startMapping->dataFacade.GetNumberOfNodes()));
if (finalWeight< numeric_limits<EdgeWeight>::max())
if (finalWeight < INVALID_EDGE_WEIGHT)
return MakeRouteFromCrossesPath(finalPath, route);
else
return OsrmRouter::RouteNotFound;
@ -1070,8 +1041,6 @@ OsrmRouter::ResultCode OsrmRouter::MakeTurnAnnotation(RawRoutingResultT const &
SegT const & segBegin = routingResult.m_sourceEdge.m_seg;
SegT const & segEnd = routingResult.m_targetEdge.m_seg;
//ASSERT(segBegin.IsValid(), ());
//ASSERT(segEnd.IsValid(), ());
double estimateTime = 0;
LOG(LDEBUG, ("Length:", routingResult.m_routePath.shortest_path_length));
@ -1477,6 +1446,13 @@ void OsrmRouter::GetTurnDirection(PathData const & node1,
Index::FeaturesLoaderGuard loader1(*m_pIndex, routingMapping->GetMwmId());
Index::FeaturesLoaderGuard loader2(*m_pIndex, routingMapping->GetMwmId());
if (!(seg1.IsValid() && seg2.IsValid()))
{
LOG(LWARNING, ("Some turns can't load geometry"));
turn.m_turn = turns::NoTurn;
return;
}
loader1.GetFeature(seg1.m_fid, ft1);
loader2.GetFeature(seg2.m_fid, ft2);

27
routing/osrm_router.hpp
View file

@ -115,6 +115,25 @@ private:
typedef shared_ptr<RoutingMapping> RoutingMappingPtrT;
//! \brief The MappingGuard struct. Asks mapping to load all data on construction and free it on destruction
class MappingGuard
{
RoutingMappingPtrT const m_mapping;
public:
MappingGuard(RoutingMappingPtrT const mapping): m_mapping(mapping)
{
m_mapping->Map();
m_mapping->LoadFacade();
}
~MappingGuard()
{
m_mapping->Unmap();
m_mapping->FreeFacade();
}
};
/*! Manager for loading, cashing and building routing indexes.
* Builds and shares special routing contexts.
*/
@ -255,9 +274,15 @@ private:
return accumulate(path.begin(), path.end(), 0, [](EdgeWeight sum, RoutePathCross const & elem){return sum+elem.weight;});
}
FeatureGraphNode const & FilterWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
MultiroutingTaskPointT::const_iterator FilterWeightsMatrix(MultiroutingTaskPointT const & sources, MultiroutingTaskPointT const & targets,
std::vector<EdgeWeight> &weightMatrix, bool const filterSource);
/*!
* \brief Makes route (points turns and other annotations) and submits it to @route class
* \param path vector of pathes through mwms
* \param route class to render final route
* \return NoError or error code
*/
ResultCode MakeRouteFromCrossesPath(CheckedPathT const & path, Route & route);
NodeID GetTurnTargetNode(NodeID src, NodeID trg, QueryEdge::EdgeData const & edgeData, RoutingMappingPtrT const & routingMapping);
void GetPossibleTurns(NodeID node,