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

[OpenLR] Use double for distances.

Browse source
This commit is contained in:
Sergey Magidovich 2018-01-26 16:04:07 +03:00 • committed by Yuri Gorshenin
parent b99673f4e6
commit 25be811a83
7 changed files with 40 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
openlr/candidate_paths_getter.cpp
View file

@ -63,7 +63,7 @@ public:
return m_isLastPoint ? e.GetEndPoint() : e.GetStartPoint();
}
m2::PointD GetBearingEndPoint(Graph::Edge const & e, uint32_t const distanceM)
m2::PointD GetBearingEndPoint(Graph::Edge const & e, double const distanceM)
{
if (distanceM < m_bearDistM && m_bearDistM <= distanceM + EdgeLength(e))
{
@ -79,7 +79,7 @@ public:
}
private:
uint32_t m_bearDistM;
double m_bearDistM;
bool m_isLastPoint;
};
} // namespace
@ -144,13 +144,13 @@ bool CandidatePathsGetter::GetLineCandidatesForPoints(
lineCandidates.emplace_back();
auto const isLastPoint = i == points.size() - 1;
auto const distanceToNextPoint =
double const distanceToNextPointM =
(isLastPoint ? points[i - 1] : points[i]).m_distanceToNextPoint;
vector<m2::PointD> pointCandidates;
m_pointsGetter.GetCandidatePoints(MercatorBounds::FromLatLon(points[i].m_latLon),
pointCandidates);
GetLineCandidates(points[i], isLastPoint, distanceToNextPoint, pointCandidates,
GetLineCandidates(points[i], isLastPoint, distanceToNextPointM, pointCandidates,
lineCandidates.back());
if (lineCandidates.back().empty())
@ -182,7 +182,7 @@ void CandidatePathsGetter::GetStartLines(vector<m2::PointD> const & points, bool
}
void CandidatePathsGetter::GetAllSuitablePaths(Graph::EdgeVector const & startLines,
bool const isLastPoint, uint32_t const bearDistM,
bool const isLastPoint, double const bearDistM,
FunctionalRoadClass const frc,
vector<LinkPtr> & allPaths)
{
@ -244,7 +244,7 @@ void CandidatePathsGetter::GetAllSuitablePaths(Graph::EdgeVector const & startLi
void CandidatePathsGetter::GetBestCandidatePaths(
vector<LinkPtr> const & allPaths, bool const isLastPoint, uint32_t const requiredBearing,
uint32_t const bearDistM, m2::PointD const & startPoint, vector<Graph::EdgeVector> & candidates)
double const bearDistM, m2::PointD const & startPoint, vector<Graph::EdgeVector> & candidates)
{
set<CandidatePath> candidatePaths;
set<CandidatePath> fakeEndingsCandidatePaths;
@ -253,8 +253,7 @@ void CandidatePathsGetter::GetBestCandidatePaths(
for (auto const & l : allPaths)
{
auto const bearStartPoint = pointsSelector.GetBearingStartPoint(l->GetStartEdge());
auto const startPointsDistance =
static_cast<uint32_t>(MercatorBounds::DistanceOnEarth(bearStartPoint, startPoint));
auto const startPointsDistance = MercatorBounds::DistanceOnEarth(bearStartPoint, startPoint);
// Number of edges counting from the last one to check bearing on. Accorfing to OpenLR spec
// we have to check bearing on a point that is no longer than 25 meters traveling down the path.
@ -324,12 +323,12 @@ void CandidatePathsGetter::GetBestCandidatePaths(
void CandidatePathsGetter::GetLineCandidates(openlr::LocationReferencePoint const & p,
bool const isLastPoint,
uint32_t const distanceToNextPoint,
double const distanceToNextPointM,
vector<m2::PointD> const & pointCandidates,
vector<Graph::EdgeVector> & candidates)
{
uint32_t const kDefaultBearDistM = 25;
uint32_t const bearDistM = min(kDefaultBearDistM, distanceToNextPoint);
double const kDefaultBearDistM = 25.0;
double const bearDistM = min(kDefaultBearDistM, distanceToNextPointM);
LOG(LINFO, ("BearDist is", bearDistM));

18
openlr/candidate_paths_getter.hpp
View file

@ -39,7 +39,7 @@ private:
// TODO(mgsergio): Rename to Vertex.
struct Link
{
Link(LinkPtr const & parent, Graph::Edge const & edge, uint32_t const distanceM)
Link(LinkPtr const & parent, Graph::Edge const & edge, double const distanceM)
: m_parent(parent)
, m_edge(edge)
, m_distanceM(distanceM)
@ -54,7 +54,7 @@ private:
LinkPtr const m_parent;
Graph::Edge const m_edge;
uint32_t const m_distanceM;
double const m_distanceM;
bool const m_hasFake;
};
@ -66,8 +66,8 @@ private:
CandidatePath() = default;
CandidatePath(LinkPtr const path, uint32_t const bearingDiff, uint32_t const pathDistanceDiff,
uint32_t const startPointDistance)
CandidatePath(LinkPtr const path, uint32_t const bearingDiff, double const pathDistanceDiff,
double const startPointDistance)
: m_path(path)
, m_bearingDiff(bearingDiff)
, m_pathDistanceDiff(pathDistanceDiff)
@ -87,9 +87,9 @@ private:
LinkPtr m_path = nullptr;
uint32_t m_bearingDiff = std::numeric_limits<uint32_t>::max(); // Domain is roughly [0, 30]
uint32_t m_pathDistanceDiff =
double m_pathDistanceDiff =
std::numeric_limits<uint32_t>::max(); // Domain is roughly [0, 25]
uint32_t m_startPointDistance =
double m_startPointDistance =
std::numeric_limits<uint32_t>::max(); // Domain is roughly [0, 50]
};
@ -109,16 +109,16 @@ private:
Graph::EdgeVector & edges);
void GetAllSuitablePaths(Graph::EdgeVector const & startLines, bool const isLastPoint,
uint32_t const bearDistM, FunctionalRoadClass const frc,
double const bearDistM, FunctionalRoadClass const frc,
std::vector<LinkPtr> & allPaths);
void GetBestCandidatePaths(std::vector<LinkPtr> const & allPaths, bool const isLastPoint,
uint32_t const requiredBearing, uint32_t const bearDistM,
uint32_t const requiredBearing, double const bearDistM,
m2::PointD const & startPoint,
std::vector<Graph::EdgeVector> & candidates);
void GetLineCandidates(openlr::LocationReferencePoint const & p, bool const isLastPoint,
uint32_t const distanceToNextPoint,
double const distanceToNextPointM,
std::vector<m2::PointD> const & pointCandidates,
std::vector<Graph::EdgeVector> & candidates);

5
openlr/helpers.cpp
View file

@ -18,10 +18,9 @@ bool PointsAreClose(m2::PointD const & p1, m2::PointD const & p2)
return MercatorBounds::DistanceOnEarth(p1, p2) < kMwmRoadCrossingRadiusMeters;
}
// TODO(mgsergio): Try to use double instead of uint32_t and leave whait is better.
uint32_t EdgeLength(Graph::Edge const & e)
double EdgeLength(Graph::Edge const & e)
{
return static_cast<uint32_t>(MercatorBounds::DistanceOnEarth(e.GetStartPoint(), e.GetEndPoint()));
return MercatorBounds::DistanceOnEarth(e.GetStartPoint(), e.GetEndPoint());
}
bool EdgesAreAlmostEqual(Graph::Edge const & e1, Graph::Edge const & e2)

3
openlr/helpers.hpp
View file

@ -13,8 +13,7 @@ class RoadInfoGetter;
bool PointsAreClose(m2::PointD const & p1, m2::PointD const & p2);
// TODO(mgsergio): Try to use double instead of uint32_t and leave whait is better.
uint32_t EdgeLength(Graph::Edge const & e);
double EdgeLength(Graph::Edge const & e);
bool EdgesAreAlmostEqual(Graph::Edge const & e1, Graph::Edge const & e2);

25
openlr/openlr_decoder.cpp
View file

@ -132,12 +132,12 @@ void ExpandFakes(Index const & index, Graph & g, Graph::EdgeVector & path)
// to some point alog that path and drop everything form the start to that point or from
// that point to the end.
template <typename InputIterator>
InputIterator CutOffset(InputIterator start, InputIterator const stop, uint32_t const offset)
InputIterator CutOffset(InputIterator start, InputIterator const stop, double const offset)
{
if (offset == 0)
return start;
for (uint32_t distance = 0; start != stop; ++start)
for (double distance = 0.0; start != stop; ++start)
{
auto const edgeLen = EdgeLength(*start);
if (distance <= offset && offset < distance + edgeLen)
@ -384,25 +384,24 @@ bool OpenLRDecoder::DecodeSingleSegment(LinearSegment const & segment, Index con
for (auto const & part : resultPath)
route.insert(end(route), begin(part), end(part));
uint32_t requiredRouteDistanceM = 0;
double requiredRouteDistanceM = 0.0;
// Sum app all distances between points. Last point's m_distanceToNextPoint
// should be equal to zero, but let's skip it just in case.
for (auto it = begin(points); it != prev(end(points)); ++it)
requiredRouteDistanceM += it->m_distanceToNextPoint;
uint32_t actualRouteDistanceM = 0;
double actualRouteDistanceM = 0.0;
for (auto const & e : route)
actualRouteDistanceM += EdgeLength(e);
auto const scale = static_cast<double>(actualRouteDistanceM) / requiredRouteDistanceM;
auto const scale = actualRouteDistanceM / requiredRouteDistanceM;
LOG(LDEBUG, ("actualRouteDistance:", actualRouteDistanceM,
"requiredRouteDistance:", requiredRouteDistanceM, "scale:", scale));
auto const positiveOffset =
static_cast<uint32_t>(segment.m_locationReference.m_positiveOffsetMeters * scale);
auto const negativeOffset =
static_cast<uint32_t>(segment.m_locationReference.m_negativeOffsetMeters * scale);
auto const positiveOffsetM = segment.m_locationReference.m_positiveOffsetMeters * scale;
auto const negativeOffsetM = segment.m_locationReference.m_negativeOffsetMeters * scale;
if (positiveOffset + negativeOffset >= requiredRouteDistanceM)
if (positiveOffsetM + negativeOffsetM >= requiredRouteDistanceM)
{
++stat.m_wrongOffsets;
LOG(LINFO, ("Wrong offsets for segment:", segment.m_segmentId));
@ -410,9 +409,9 @@ bool OpenLRDecoder::DecodeSingleSegment(LinearSegment const & segment, Index con
}
ExpandFakes(index, graph, route);
ASSERT(none_of(begin(route), end(route), mem_fn(&Graph::Edge::IsFake)), ());
CopyWithoutOffsets(begin(route), end(route), back_inserter(path.m_path), positiveOffset,
negativeOffset);
ASSERT(none_of(begin(route), end(route), mem_fn(&Graph::Edge::IsFake)), (segment.m_segmentId));
CopyWithoutOffsets(begin(route), end(route), back_inserter(path.m_path), positiveOffsetM,
negativeOffsetM);
if (path.m_path.empty())
{

9
openlr/paths_connector.cpp
View file

@ -6,7 +6,6 @@
#include <algorithm>
#include <map>
#include <numeric>
#include <queue>
#include <tuple>
@ -42,7 +41,7 @@ int32_t PathOverlappingLen(Graph::EdgeVector const & a, Graph::EdgeVector const
}
bool ValidatePath(Graph::EdgeVector const & path,
uint32_t const distanceToNextPoint,
double const distanceToNextPoint,
double const pathLengthTolerance)
{
@ -88,7 +87,7 @@ bool PathsConnector::ConnectCandidates(vector<LocationReferencePoint> const & po
bool found = false;
auto const & point = points[i - 1];
auto const distanceToNextPoint = point.m_distanceToNextPoint;
auto const distanceToNextPoint = static_cast<double>(point.m_distanceToNextPoint);
auto const & fromCandidates = lineCandidates[i - 1];
auto const & toCandidates = lineCandidates[i];
auto & resultPathPart = resultPath[i - 1];
@ -159,6 +158,8 @@ bool PathsConnector::FindShortestPath(Graph::Edge const & from, Graph::Edge cons
uint32_t m_score;
};
ASSERT(from.HasRealPart() && to.HasRealPart(), ());
priority_queue<State, vector<State>, greater<State>> q;
map<Graph::Edge, uint32_t> scores;
map<Graph::Edge, Graph::Edge> links;
@ -218,7 +219,7 @@ bool PathsConnector::FindShortestPath(Graph::Edge const & from, Graph::Edge cons
bool PathsConnector::ConnectAdjacentCandidateLines(Graph::EdgeVector const & from,
Graph::EdgeVector const & to,
FunctionalRoadClass const frc,
uint32_t const distanceToNextPoint,
double const distanceToNextPoint,
Graph::EdgeVector & resultPath)
{

2
openlr/paths_connector.hpp
View file

@ -26,7 +26,7 @@ private:
bool ConnectAdjacentCandidateLines(Graph::EdgeVector const & from, Graph::EdgeVector const & to,
FunctionalRoadClass const frc,
uint32_t const distanceToNextPoint,
double const distanceToNextPoint,
Graph::EdgeVector & resultPath);
double m_pathLengthTolerance;