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

Review fixes.

Browse source
This commit is contained in:
Vladimir Byko-Ianko 2019-04-26 17:31:56 +03:00
parent a2348f79c5
commit 611cced6e5
5 changed files with 50 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
openlr/candidate_paths_getter.cpp
View file

@ -70,7 +70,7 @@ bool CandidatePathsGetter::GetLineCandidatesForPoints(
if (i != points.size() - 1 && points[i].m_distanceToNextPoint == 0)
{
LOG(LINFO, ("Distance to next point is zero. Skipping the whole segment"));
++m_stats.m_dnpIsZero;
++m_stats.m_zeroDistToNextPointCount;
return false;
}

33
openlr/score_candidate_paths_getter.cpp
View file

@ -21,6 +21,7 @@
#include <queue>
#include <set>
#include <tuple>
#include <utility>
using namespace routing;
using namespace std;
@ -42,16 +43,16 @@ double ToAngleInDeg(uint32_t angleInBuckets)
uint32_t BearingInDeg(m2::PointD const & a, m2::PointD const & b)
{
auto const angle = location::AngleToBearing(base::RadToDeg(ang::AngleTo(a, b)));
CHECK_LESS_OR_EQUAL(angle, 360.0, ("Angle should be less than or equal to 360."));
CHECK_GREATER_OR_EQUAL(angle, 0.0, ("Angle should be greater than or equal to 0."));
CHECK_LESS_OR_EQUAL(angle, 360.0, ());
CHECK_GREATER_OR_EQUAL(angle, 0.0, ());
return angle;
}
double DifferenceInDeg(double a1, double a2)
{
auto const diff = 180.0 - abs(abs(a1 - a2) - 180.0);
CHECK_LESS_OR_EQUAL(diff, 180.0, ("Difference should be less than or equal to 360."));
CHECK_GREATER_OR_EQUAL(diff, 0.0, ("Difference should be greater than or equal to 0."));
CHECK_LESS_OR_EQUAL(diff, 180.0, ());
CHECK_GREATER_OR_EQUAL(diff, 0.0, ());
return diff;
}
} // namespace
@ -91,7 +92,7 @@ bool ScoreCandidatePathsGetter::GetLineCandidatesForPoints(
if (i != points.size() - 1 && points[i].m_distanceToNextPoint == 0)
{
LOG(LINFO, ("Distance to next point is zero. Skipping the whole segment"));
++m_stats.m_dnpIsZero;
++m_stats.m_zeroDistToNextPointCount;
return false;
}
@ -122,9 +123,10 @@ bool ScoreCandidatePathsGetter::GetLineCandidatesForPoints(
void ScoreCandidatePathsGetter::GetAllSuitablePaths(ScoreEdgeVec const & startLines,
bool isLastPoint, double bearDistM,
FunctionalRoadClass functionalRoadClass,
FormOfWay formOfWay, vector<LinkPtr> & allPaths)
FormOfWay formOfWay,
vector<shared_ptr<Link>> & allPaths)
{
queue<LinkPtr> q;
queue<shared_ptr<Link>> q;
for (auto const & e : startLines)
{
@ -132,9 +134,8 @@ void ScoreCandidatePathsGetter::GetAllSuitablePaths(ScoreEdgeVec const & startLi
if (!PassesRestrictionV3(e.m_edge, functionalRoadClass, formOfWay, m_infoGetter, roadScore))
continue;
auto const u =
make_shared<Link>(nullptr /* parent */, e.m_edge, 0 /* distanceM */, e.m_score, roadScore);
q.push(u);
q.push(
make_shared<Link>(nullptr /* parent */, e.m_edge, 0 /* distanceM */, e.m_score, roadScore));
}
// Filling |allPaths| staring from |startLines| which have passed functional road class
@ -150,7 +151,7 @@ void ScoreCandidatePathsGetter::GetAllSuitablePaths(ScoreEdgeVec const & startLi
if (u->m_distanceM + currentEdgeLen >= bearDistM)
{
allPaths.push_back(u);
allPaths.emplace_back(move(u));
continue;
}
@ -187,7 +188,7 @@ void ScoreCandidatePathsGetter::GetAllSuitablePaths(ScoreEdgeVec const & startLi
}
void ScoreCandidatePathsGetter::GetBestCandidatePaths(
vector<LinkPtr> const & allPaths, bool isLastPoint, uint32_t requiredBearing,
vector<shared_ptr<Link>> const & allPaths, bool isLastPoint, uint32_t requiredBearing,
double bearDistM, m2::PointD const & startPoint, ScorePathVec & candidates)
{
CHECK_GREATER_OR_EQUAL(requiredBearing, 0, ());
@ -196,9 +197,9 @@ void ScoreCandidatePathsGetter::GetBestCandidatePaths(
multiset<CandidatePath, greater<>> candidatePaths;
BearingPointsSelector pointsSelector(static_cast<uint32_t>(bearDistM), isLastPoint);
for (auto const & l : allPaths)
for (auto const & link : allPaths)
{
auto const bearStartPoint = pointsSelector.GetStartPoint(l->GetStartEdge());
auto const bearStartPoint = pointsSelector.GetStartPoint(link->GetStartEdge());
// Number of edges counting from the last one to check bearing on. According to OpenLR spec
// we have to check bearing on a point that is no longer than 25 meters traveling down the path.
@ -213,7 +214,7 @@ void ScoreCandidatePathsGetter::GetBestCandidatePaths(
// ^ this one.
// So we want to check them all.
uint32_t traceBackIterationsLeft = 3;
for (auto part = l; part; part = part->m_parent)
for (auto part = link; part; part = part->m_parent)
{
if (traceBackIterationsLeft == 0)
break;
@ -274,7 +275,7 @@ void ScoreCandidatePathsGetter::GetLineCandidates(openlr::LocationReferencePoint
auto const startPoint = MercatorBounds::FromLatLon(p.m_latLon);
vector<LinkPtr> allPaths;
vector<shared_ptr<Link>> allPaths;
GetAllSuitablePaths(startLines, isLastPoint, bearDistM, p.m_functionalRoadClass, p.m_formOfWay,
allPaths);

15
openlr/score_candidate_paths_getter.hpp
View file

@ -32,12 +32,9 @@ public:
std::vector<ScorePathVec> & lineCandidates);
private:
struct Link;
using LinkPtr = std::shared_ptr<Link>;
struct Link
{
Link(LinkPtr const & parent, Graph::Edge const & edge, double distanceM,
Link(std::shared_ptr<Link> const & parent, Graph::Edge const & edge, double distanceM,
Score pointScore, Score rfcScore)
: m_parent(parent)
, m_edge(edge)
@ -52,7 +49,7 @@ private:
Graph::Edge GetStartEdge() const;
LinkPtr const m_parent;
std::shared_ptr<Link> const m_parent;
Graph::Edge const m_edge;
double const m_distanceM;
Score const m_pointScore;
@ -65,7 +62,7 @@ private:
{
CandidatePath() = default;
CandidatePath(LinkPtr const path, Score pointScore, Score rfcScore, Score bearingScore)
CandidatePath(std::shared_ptr<Link> const path, Score pointScore, Score rfcScore, Score bearingScore)
: m_path(path)
, m_pointScore(pointScore)
, m_roadScore(rfcScore)
@ -77,7 +74,7 @@ private:
Score GetScore() const { return m_pointScore + m_roadScore + m_bearingScore; }
LinkPtr m_path = nullptr;
std::shared_ptr<Link> m_path = nullptr;
Score m_pointScore = 0;
Score m_roadScore = 0;
Score m_bearingScore = 0;
@ -100,9 +97,9 @@ private:
/// then should be taken the member |m_parent| of the item and so on till the beginning.
void GetAllSuitablePaths(ScoreEdgeVec const & startLines, bool isLastPoint,
double bearDistM, FunctionalRoadClass functionalRoadClass,
FormOfWay formOfWay, std::vector<LinkPtr> & allPaths);
FormOfWay formOfWay, std::vector<std::shared_ptr<Link>> & allPaths);
void GetBestCandidatePaths(std::vector<LinkPtr> const & allPaths, bool isLastPoint,
void GetBestCandidatePaths(std::vector<std::shared_ptr<Link>> const & allPaths, bool isLastPoint,
uint32_t requiredBearing, double bearDistM,
m2::PointD const & startPoint, ScorePathVec & candidates);

46
openlr/score_paths_connector.cpp
View file

@ -106,7 +106,7 @@ bool ValidatePathByLength(Graph::EdgeVector const & path, double distanceToNextP
// 0 <= |pathDiffRatio| <= 1. The more pathDiffRatio the closer |distanceToNextPoint| and |pathLen|.
double const pathDiffRatio =
1.0 - AbsDifference(distanceToNextPoint, pathLen) / max(distanceToNextPoint, pathLen);
1.0 - abs(distanceToNextPoint - pathLen) / max(distanceToNextPoint, pathLen);
bool const shortPath = path.size() <= 2;
double constexpr kMinValidPathDiffRation = 0.6;
@ -162,9 +162,9 @@ bool ScorePathsConnector::FindBestPath(vector<LocationReferencePoint> const & po
if (!ValidatePathByLength(path, distanceToNextPoint, pathLenScore))
continue;
result.emplace_back(pathLenScore + GetScoreForUniformity(path) +
fromCandidates[fromInd].m_score + toCandidates[toInd].m_score,
move(path));
auto const score = pathLenScore + GetScoreForUniformity(path) +
fromCandidates[fromInd].m_score + toCandidates[toInd].m_score;
result.emplace_back(score, move(path));
}
}
@ -235,42 +235,42 @@ bool ScorePathsConnector::FindShortestPath(Graph::Edge const & from, Graph::Edge
auto const state = q.top();
q.pop();
auto const & u = state.m_edge;
auto const & stateEdge = state.m_edge;
// TODO(mgsergio): Unify names: use either score or distance.
auto const us = state.m_score;
auto const stateScore = state.m_score;
if (us > maxPathLength + lengthToleranceM)
if (stateScore > maxPathLength + lengthToleranceM)
continue;
if (us > scores[u])
if (stateScore > scores[stateEdge])
continue;
if (u == to)
if (stateEdge == to)
{
for (auto e = u; e != from; e = links[e])
path.emplace_back(e);
for (auto edge = stateEdge; edge != from; edge = links[edge])
path.emplace_back(edge);
path.emplace_back(from);
reverse(begin(path), end(path));
return true;
}
Graph::EdgeVector edges;
m_graph.GetOutgoingEdges(u.GetEndJunction(), edges);
for (auto const & e : edges)
m_graph.GetOutgoingEdges(stateEdge.GetEndJunction(), edges);
for (auto const & edge : edges)
{
if (!ConformLfrcnpV3(e, lowestFrcToNextPoint, m_infoGetter))
if (!ConformLfrcnpV3(edge, lowestFrcToNextPoint, m_infoGetter))
continue;
CHECK(!u.IsFake(), ());
CHECK(!e.IsFake(), ());
CHECK(!stateEdge.IsFake(), ());
CHECK(!edge.IsFake(), ());
auto const it = scores.find(e);
auto const eScore = us + EdgeLength(e);
auto const it = scores.find(edge);
auto const eScore = stateScore + EdgeLength(edge);
if (it == end(scores) || it->second > eScore)
{
scores[e] = eScore;
links[e] = u;
q.emplace(e, eScore);
scores[edge] = eScore;
links[edge] = stateEdge;
q.emplace(edge, eScore);
}
}
}
@ -305,11 +305,11 @@ bool ScorePathsConnector::ConnectAdjacentCandidateLines(Graph::EdgeVector const
if (!found)
return false;
// Skip the last edge from |from| because it already took its place at begin(shortestPath).
CHECK_EQUAL(from.back(), shortestPath.front(), ());
resultPath.insert(resultPath.end(), from.cbegin(), prev(from.cend()));
resultPath.insert(resultPath.end(), shortestPath.cbegin(), shortestPath.cend());
// Skip the first edge from |to| because it already took its place at prev(end(shortestPath)).
CHECK_EQUAL(to.front(), shortestPath.back(), ());
resultPath.insert(resultPath.end(), next(to.begin()), to.end());
return !resultPath.empty();

6
openlr/stats.hpp
View file

@ -20,7 +20,7 @@ struct alignas(kCacheLineSize) Stats
m_noCandidateFound += s.m_noCandidateFound;
m_noShortestPathFound += s.m_noShortestPathFound;
m_wrongOffsets += s.m_wrongOffsets;
m_dnpIsZero += s.m_dnpIsZero;
m_zeroDistToNextPointCount += s.m_zeroDistToNextPointCount;
}
void Report() const
@ -28,7 +28,7 @@ struct alignas(kCacheLineSize) Stats
LOG(LINFO, ("Total routes handled:", m_routesHandled));
LOG(LINFO, ("Failed:", m_routesFailed));
LOG(LINFO, ("No candidate lines:", m_noCandidateFound));
LOG(LINFO, ("Wrong distance to next point:", m_dnpIsZero));
LOG(LINFO, ("Wrong distance to next point:", m_zeroDistToNextPointCount));
LOG(LINFO, ("Wrong offsets:", m_wrongOffsets));
LOG(LINFO, ("No shortest path:", m_noShortestPathFound));
}
@ -39,7 +39,7 @@ struct alignas(kCacheLineSize) Stats
uint32_t m_noShortestPathFound = 0;
uint32_t m_wrongOffsets = 0;
// Number of zeroed distance-to-next point values in the input.
uint32_t m_dnpIsZero = 0;
uint32_t m_zeroDistToNextPointCount = 0;
};
} // namespace V2
} // namespace openlr